#!/usr/bin/python3
"""
iRobot Hybrid Trader v5.0
Гибридная стратегия с полной поддержкой Tinkoff API через транспортный модуль
"""

import os
import sys
import json
import time
import logging
import random
from datetime import datetime, timedelta
from pathlib import Path
from typing import Optional, Dict, Any, List

# ========== ИМПОРТ МОДУЛЕЙ ==========
try:
    # Модуль безопасности
    sys.path.insert(0, '/usr/lib/irobot-trader')
    from safety_check import safety_check
    SAFETY_MODULE_AVAILABLE = True
except ImportError:
    SAFETY_MODULE_AVAILABLE = False
    
    def safety_check(config_path):
        """Заглушка если модуль безопасности не установлен"""
        timestamp = datetime.now().strftime("%H:%M:%S")
        print(f"{timestamp} - ⚠️  Модуль безопасности не найден")
        return True, None

try:
    # Транспортный модуль Tinkoff API
    sys.path.insert(0, '/usr/lib/irobot-trader')
    from tinkoff_client import TinkoffClient, create_client_from_config
    TINKOFF_MODULE_AVAILABLE = True
except ImportError:
    TINKOFF_MODULE_AVAILABLE = False
    TinkoffClient = None
    create_client_from_config = None

# ========== КЛАСС ТОРГОВОГО РОБОТА ==========

class HybridTrader:
    def __init__(self, config_file: str = "/etc/irobot-trader.json"):
        """
        Инициализация торгового робота
        
        Args:
            config_file: Путь к файлу конфигурации
        """
        # Загружаем конфиг
        self.config = self.load_and_adapt_config(config_file)
        
        # ========== ПРОВЕРКА БЕЗОПАСНОСТИ ==========
        if SAFETY_MODULE_AVAILABLE:
            logging.info("🔐 Проверка безопасности конфигурации...")
            self.is_safe, self.api_token = safety_check(config_file)
            
            if not self.is_safe:
                logging.error("❌ Конфигурация небезопасна!")
                logging.error("❌ Запуск остановлен")
                sys.exit(1)
        else:
            self.is_safe = True
            self.api_token = (
                self.config.get("tinkoff_token") or
                self.config.get("tinkoff_sandbox_token") or
                self.config.get("tinkoff_real_token") or
                self.config.get("sandbox_token") or
                self.config.get("real_token")
            )
        
        # ========== НАСТРОЙКИ ИЗ КОНФИГА ==========
        self.use_sandbox = self.config.get("use_sandbox", True)
        
        # Капитал
        self.capital = self.config.get("capital_rub", 
                      self.config.get("capital", 1000000))
        
        # Режимы торговли
        self.hft_enabled = self.config.get("hft_mode", 
                         self.config.get("hft_enabled", True))
        self.day_enabled = self.config.get("daily_mode", 
                         self.config.get("day_enabled", True))
        
        # Параметры стратегии
        self.trading_start = self.config.get("trading_hours", {}).get("start", 10)
        self.trading_end = self.config.get("trading_hours", {}).get("end", 11)
        self.min_rise = self.config.get("min_rise", 0.01)
        self.stop_loss = self.config.get("stop_loss", 0.01)
        self.take_profit = self.config.get("take_profit", 0.02)
        
        # Акции для торговли
        self.stocks = self._get_stocks_list()
        self.max_positions = self.config.get("max_positions", 3)
        
        # ========== ИНИЦИАЛИЗАЦИЯ API КЛИЕНТА ==========
        self.api_client = None
        if TINKOFF_MODULE_AVAILABLE and self.api_token:
            try:
                self.api_client = create_client_from_config(self.config)
                if self.api_client:
                    mode = "ПЕСОЧНИЦА" if self.use_sandbox else "РЕАЛЬНАЯ ТОРГОВЛЯ"
                    logging.info(f"🔗 Подключено к Tinkoff API ({mode})")
                    
                    if not self.use_sandbox:
                        self._confirm_real_trading()
                else:
                    logging.warning("⚠️  Не удалось создать API клиент, переходим в симуляцию")
                    
            except Exception as e:
                logging.error(f"❌ Ошибка инициализации API: {e}")
                self.api_client = None
        
        # ========== СОСТОЯНИЕ ТОРГОВЛИ ==========
        self.positions = {}
        self.hft_positions = {}
        self.day_positions = {}
        self.open_orders = {}
        
        # Статистика
        self.daily_stats = {
            "hft_trades": 0,
            "hft_profit": 0,
            "day_trades": 0,
            "day_profit": 0,
            "total_trades": 0,
            "real_trades": 0,
            "commission": 0,
            "start_capital": self.capital
        }
        
        # Обновляем баланс если есть API
        self._update_balance()
        
        # ========== ЛОГИРОВАНИЕ СТАТУСА ==========
        logging.info(f"🤖 iRobot Hybrid Trader v5.0 загружен")
        
        if self.api_client:
            mode = "ПЕСОЧНИЦА" if self.use_sandbox else "РЕАЛЬНАЯ ТОРГОВЛЯ"
            logging.info(f"⚙️  Режим: {mode}")
        else:
            logging.info("🔓 Режим: СИМУЛЯЦИЯ (без API)")
        
        logging.info(f"💰 Капитал: {self.capital:,.0f} руб.")
        logging.info(f"🕐 Время торгов: {self.trading_start}:00 - {self.trading_end}:00")
        logging.info(f"📈 Акции: {', '.join(self.stocks[:5])}" + 
                    ("..." if len(self.stocks) > 5 else ""))
        logging.info(f"⚡ HFT: {'ВКЛ' if self.hft_enabled else 'ВЫКЛ'}")
        logging.info(f"🌅 Дневная: {'ВКЛ' if self.day_enabled else 'ВЫКЛ'}")
    
    def _confirm_real_trading(self):
        """Запрос подтверждения для реальной торговли"""
        if not self.api_client or self.use_sandbox:
            return
        
        if not sys.stdin.isatty():
            logging.warning("Неинтерактивный режим, продолжаем...")
            return
        
        try:
            print("\n" + "="*60)
            print("⚠️  ВНИМАНИЕ: РЕАЛЬНАЯ ТОРГОВЛЯ ⚠️")
            print(f"Капитал: {self.capital:,.0f} руб. (РЕАЛЬНЫЕ ДЕНЬГИ)")
            print("Все сделки будут РЕАЛЬНЫМИ!")
            print("="*60)
            
            confirm = input("\nПодтвердите запуск реальной торговли (введите 'REAL'): ")
            if confirm.strip().upper() != "REAL":
                logging.error("❌ Запуск отменен пользователем")
                sys.exit(0)
            logging.info("✅ Подтверждение получено")
        except EOFError:
            logging.warning("Неинтерактивный режим, продолжаем...")
    
    def _update_balance(self):
        """Обновление баланса из API или конфига"""
        if self.api_client and not self.use_sandbox:
            try:
                portfolio = self.api_client.get_portfolio()
                if portfolio:
                    # Вариант 1: Ищем RUB валюту в positions
                    positions = portfolio.get('positions', [])
                    for pos in positions:
                        if pos.get('instrumentType') == 'Currency' and pos.get('currency') == 'RUB':
                            balance = pos.get('balance', 0)
                            if balance > 0:
                                self.capital = balance
                                logging.info(f"💰 Текущий баланс: {self.capital:,.0f} руб.")
                                return
                    
                    # Вариант 2: Смотрим totalAmountRub в payload
                    total_amount_rub = portfolio.get('totalAmountRub', {}).get('value', 0)
                    if total_amount_rub > 0:
                        self.capital = total_amount_rub
                        logging.info(f"💰 Текущий баланс (totalAmountRub): {self.capital:,.0f} руб.")
                        return
                    
                    # Вариант 3: Смотрим totalAmountCurrencies
                    total_currencies = portfolio.get('totalAmountCurrencies', {}).get('value', 0)
                    if total_currencies > 0:
                        self.capital = total_currencies
                        logging.info(f"💰 Текущий баланс (currencies): {self.capital:,.0f} руб.")
                        return
                    
                    logging.warning("⚠️  Не удалось определить баланс из портфеля")
                        
            except Exception as e:
                logging.debug(f"Не удалось обновить баланс: {e}")
        elif self.api_client and self.use_sandbox:
            # Для песочницы используем конфиг или запрашиваем баланс
            try:
                sandbox_balance = self.config.get('sandbox_balance', self.capital)
                if sandbox_balance != self.capital:
                    self.capital = sandbox_balance
                    logging.info(f"💰 Баланс песочницы: {self.capital:,.0f} руб.")
            except Exception as e:
                logging.debug(f"Не удалось обновить баланс песочницы: {e}")
    
    # ========== МЕТОДЫ РАБОТЫ С ЦЕНАМИ ==========
    
    def get_price(self, ticker: str) -> float:
        """
        Получение текущей цены акции
        
        Args:
            ticker: Тикер акции
            
        Returns:
            Текущая цена
        """
        # Пробуем получить реальную цену через API
        if self.api_client:
            try:
                price = self.api_client.get_price(ticker)
                if price and price > 0:
                    return price
            except Exception as e:
                logging.debug(f"Ошибка получения цены {ticker} через API: {e}")
        
        # Фолбэк на симуляцию
        return self.get_simulated_price(ticker)
    
    def get_simulated_price(self, ticker: str) -> float:
        """
        Симуляция цены акции
        
        Args:
            ticker: Тикер акции
            
        Returns:
            Симулированная цена
        """
        # Базовые цены для симуляции
        base_prices = {
            "SBER": 300.0, "GAZP": 180.0, "LKOH": 6500.0,
            "TCSG": 3500.0, "YNDX": 4000.0, "VTBR": 0.05,
            "ROSN": 600.0, "TATN": 700.0, "MGNT": 8000.0,
            "MOEX": 150.0, "AFKS": 15.0, "POLY": 1000.0,
            "MTSS": 300.0, "NLMK": 200.0, "GMKN": 30000.0,
            "CHMF": 1500.0, "PLZL": 12000.0, "SNGS": 40.0,
            "BANE": 60.0, "FEES": 0.50, "TRNFP": 120000.0,
            "ALRS": 90.0, "MTLR": 25.0, "RTKM": 100.0,
            "HYDR": 0.80, "IRAO": 3.0, "RUAL": 100.0,
            "MAGN": 50.0, "PHOR": 800.0
        }
        
        base = base_prices.get(ticker.upper(), 100.0)
        
        # Симуляция рыночных движений
        now = datetime.now()
        hour = now.hour
        minute = now.minute
        second = now.second
        
        # Базовое движение по времени
        if hour == self.trading_start and minute == 0:
            # Открытие рынка - рост
            movement = self.min_rise * (1 + random.random() * 0.5)
        elif self.trading_start < hour < 12:
            # Утренняя сессия
            movement = random.random() * 0.003 - 0.0015
        elif 12 <= hour < 15:
            # Обеденная стагнация
            movement = random.random() * 0.002 - 0.001
        elif hour >= 15:
            # Вечерний спад
            movement = random.random() * 0.002 - 0.0025
        else:
            movement = 0.0
        
        # Волатильность по секундам
        second_volatility = (random.random() - 0.5) * 0.001
        
        # Случайный шум
        random_noise = (random.random() - 0.5) * 0.002
        
        # Итоговая цена
        price = base * (1 + movement + second_volatility + random_noise)
        
        return round(price, 2)
    
    # ========== МЕТОДЫ ВЫПОЛНЕНИЯ СДЕЛОК ==========
    
    def execute_hft_trade(self, ticker: str, price: float, 
                         side: str, quantity: int) -> bool:
        """
        Выполнение HFT-сделки
        
        Args:
            ticker: Тикер акции
            price: Текущая цена
            side: 'BUY' или 'SELL'
            quantity: Количество лотов
            
        Returns:
            True если сделка выполнена успешно
        """
        side_upper = side.upper()
        
        if side_upper == "BUY":
            # Проверяем лимиты
            max_hft = self.config.get("hft_max_positions", 2)
            if len(self.hft_positions) >= max_hft:
                logging.debug(f"⚠️  Лимит HFT позиций достигнут: {len(self.hft_positions)}/{max_hft}")
                return False
            
            # Выполняем покупку
            success = self._execute_trade(ticker, "BUY", quantity, price)
            
            if success:
                self.hft_positions[ticker] = {
                    "entry_price": price,
                    "entry_time": datetime.now(),
                    "quantity": quantity,
                    "target": price * (1 + self.config.get("hft_target_profit", 0.003)),
                    "stop": price * (1 - self.config.get("hft_stop_loss", 0.002))
                }
                
                profit_target = self.config.get("hft_target_profit", 0.003) * 100
                logging.info(f"⚡ HFT_BUY {ticker} {quantity}л @ {price:.2f} (цель: +{profit_target:.1f}%)")
                return True
            else:
                logging.error(f"❌ Ошибка HFT_BUY {ticker}")
                return False
        
        else:  # SELL
            if ticker not in self.hft_positions:
                logging.warning(f"⚠️  Попытка продажи отсутствующей HFT позиции: {ticker}")
                return False
            
            position = self.hft_positions[ticker]
            
            # Выполняем продажу
            success = self._execute_trade(ticker, "SELL", position["quantity"], price)
            
            if success:
                # Рассчитываем прибыль
                profit = (price - position["entry_price"]) * position["quantity"] * 10
                self.daily_stats["hft_profit"] += profit
                self.daily_stats["hft_trades"] += 1
                
                profit_pct = (price / position["entry_price"] - 1) * 100
                hold_time = (datetime.now() - position["entry_time"]).seconds
                
                logging.info(f"⚡ HFT_SELL {ticker} @ {price:.2f} ({profit_pct:+.2f}%, {hold_time}сек)")
                
                # Удаляем позицию
                del self.hft_positions[ticker]
                return True
            else:
                logging.error(f"❌ Ошибка HFT_SELL {ticker}")
                return False
    
    def execute_day_trade(self, ticker: str, price: float, 
                         side: str, quantity: int) -> bool:
        """
        Выполнение дневной сделки
        
        Args:
            ticker: Тикер акции
            price: Текущая цена
            side: 'BUY' или 'SELL'
            quantity: Количество лотов
            
        Returns:
            True если сделка выполнена успешно
        """
        side_upper = side.upper()
        
        if side_upper == "BUY":
            # Проверяем лимиты
            max_day = self.config.get("day_max_positions", self.max_positions)
            if len(self.day_positions) >= max_day:
                logging.debug(f"⚠️  Лимит дневных позиций достигнут: {len(self.day_positions)}/{max_day}")
                return False
            
            # Выполняем покупку
            success = self._execute_trade(ticker, "BUY", quantity, price)
            
            if success:
                self.day_positions[ticker] = {
                    "entry_price": price,
                    "entry_time": datetime.now(),
                    "quantity": quantity,
                    "stop": price * (1 - self.stop_loss),
                    "take_profit": price * (1 + self.take_profit)
                }
                
                logging.info(f"🌅 DAY_BUY {ticker} {quantity}л @ {price:.2f}")
                return True
            else:
                logging.error(f"❌ Ошибка DAY_BUY {ticker}")
                return False
        
        else:  # SELL
            if ticker not in self.day_positions:
                logging.warning(f"⚠️  Попытка продажи отсутствующей дневной позиции: {ticker}")
                return False
            
            position = self.day_positions[ticker]
            
            # Выполняем продажу
            success = self._execute_trade(ticker, "SELL", position["quantity"], price)
            
            if success:
                # Рассчитываем прибыль
                profit = (price - position["entry_price"]) * position["quantity"] * 10
                self.daily_stats["day_profit"] += profit
                self.daily_stats["day_trades"] += 1
                
                profit_pct = (price / position["entry_price"] - 1) * 100
                hold_time = (datetime.now() - position["entry_time"]).seconds / 3600
                
                logging.info(f"🌅 DAY_SELL {ticker} @ {price:.2f} ({profit_pct:+.2f}%, {hold_time:.1f}ч)")
                
                # Удаляем позицию
                del self.day_positions[ticker]
                return True
            else:
                logging.error(f"❌ Ошибка DAY_SELL {ticker}")
                return False
    
    def _execute_trade(self, ticker: str, operation: str, 
                      lots: int, expected_price: float) -> bool:
        """
        Выполнение сделки через API или симуляцию
        
        Args:
            ticker: Тикер акции
            operation: 'BUY' или 'SELL'
            lots: Количество лотов
            expected_price: Ожидаемая цена
            
        Returns:
            True если сделка выполнена успешно
        """
        # Если есть API клиент, используем его
        if self.api_client:
            try:
                result = self.api_client.place_market_order(ticker, operation, lots)
                if result:
                    # Обновляем статистику для реальных сделок
                    if not self.use_sandbox:
                        self.daily_stats["real_trades"] += 1
                        # Примерная комиссия 0.3%
                        trade_value = expected_price * lots * 10
                        commission = trade_value * 0.003
                        self.daily_stats["commission"] += commission
                    
                    return True
                else:
                    return False
                    
            except Exception as e:
                logging.error(f"❌ Ошибка API при выполнении сделки: {e}")
                return False
        else:
            # Симуляция
            operation_text = "ПОКУПКА" if operation.upper() == "BUY" else "ПРОДАЖА"
            logging.debug(f"🧪 СИМУЛЯЦИЯ: {operation_text} {ticker} {lots}л @ ~{expected_price:.2f}")
            
            # В симуляции всегда успешно
            return True
    
    # ========== МЕТОДЫ УПРАВЛЕНИЯ ПОЗИЦИЯМИ ==========
    
    def manage_hft_position(self, ticker: str) -> str:
        """
        Управление HFT-позицией
        
        Args:
            ticker: Тикер акции
            
        Returns:
            Результат управления
        """
        if ticker not in self.hft_positions:
            return "NO_POSITION"
        
        position = self.hft_positions[ticker]
        current_price = self.get_price(ticker)
        hold_time = (datetime.now() - position["entry_time"]).seconds
        
        # Тейк-профит
        if current_price >= position["target"]:
            self.execute_hft_trade(ticker, current_price, "SELL", position["quantity"])
            return "HFT_TAKE_PROFIT"
        
        # Стоп-лосс
        if current_price <= position["stop"]:
            self.execute_hft_trade(ticker, current_price, "SELL", position["quantity"])
            return "HFT_STOP_LOSS"
        
        # Время истекло
        max_hold = self.config.get("hft_max_hold_time", 60)
        if hold_time >= max_hold:
            self.execute_hft_trade(ticker, current_price, "SELL", position["quantity"])
            return "HFT_TIME_EXIT"
        
        return "HFT_HOLD"
    
    def manage_day_position(self, ticker: str) -> str:
        """
        Управление дневной позицией
        
        Args:
            ticker: Тикер акции
            
        Returns:
            Результат управления
        """
        if ticker not in self.day_positions:
            return "NO_POSITION"
        
        position = self.day_positions[ticker]
        current_price = self.get_price(ticker)
        
        # Стоп-лосс
        if current_price <= position["stop"]:
            self.execute_day_trade(ticker, current_price, "SELL", position["quantity"])
            return "DAY_STOP_LOSS"
        
        # Тейк-профит
        if current_price >= position["take_profit"]:
            self.execute_day_trade(ticker, current_price, "SELL", position["quantity"])
            return "DAY_TAKE_PROFIT"
        
        # Время закрытия
        sell_time = self.config.get("day_sell_time", "18:45")
        now = datetime.now().strftime("%H:%M")
        if now == sell_time:
            price_change = (current_price - position["entry_price"]) / position["entry_price"]
            
            if price_change > 0:
                self.execute_day_trade(ticker, current_price, "SELL", position["quantity"])
                return "DAY_CLOSE_PROFIT"
            else:
                logging.info(f"📅 HOLD_OVERNIGHT {ticker}: {price_change:.2%}")
                return "DAY_HOLD_OVERNIGHT"
        
        return "DAY_HOLD"
    
    # ========== ОСНОВНАЯ ТОРГОВАЯ ЛОГИКА ==========
    
    def run_hybrid_strategy(self):
        """Главный цикл гибридной стратегии"""
        now = datetime.now()
        current_time = now.strftime("%H:%M:%S")
        
        start_hour = self.trading_start
        
        # === ФАЗА 1: HFT НА ОТКРЫТИИ ===
        if self.hft_enabled and now.hour == start_hour and now.minute == 0:
            opening_time = now.replace(second=0, microsecond=0)
            
            if now <= opening_time + timedelta(seconds=90):
                # Анализ премаркета (раз в 5 секунд)
                if now.second % 5 == 0:
                    hft_candidates = [t for t in self.stocks 
                                    if t not in self.hft_positions]
                    if hft_candidates:
                        logging.debug(f"🔍 HFT кандидаты доступны: {len(hft_candidates)}")
                
                # HFT вход (первые 30 секунд)
                if now <= opening_time + timedelta(seconds=30):
                    for ticker in self.stocks:
                        if ticker not in self.hft_positions:
                            max_hft = self.config.get("hft_max_positions", 2)
                            if len(self.hft_positions) < max_hft:
                                price = self.get_price(ticker)
                                self.execute_hft_trade(ticker, price, "BUY", 5)
                
                # Управление HFT позициями
                for ticker in list(self.hft_positions.keys()):
                    self.manage_hft_position(ticker)
        
        # === ФАЗА 2: ДНЕВНАЯ СТРАТЕГИЯ ===
        if self.day_enabled:
            if start_hour <= now.hour < 18 or (now.hour == 18 and now.minute < 45):
                
                # Дневной вход в start_hour:05
                if current_time == f"{start_hour:02d}:05:00":
                    available_stocks = [
                        t for t in self.stocks
                        if t not in self.day_positions
                    ]
                    
                    max_day = self.config.get("day_max_positions", self.max_positions)
                    for ticker in available_stocks[:max_day]:
                        price = self.get_price(ticker)
                        self.execute_day_trade(ticker, price, "BUY", 10)
                
                # Управление дневными позициями (каждые 30 секунд)
                if now.second % 30 == 0:
                    for ticker in list(self.day_positions.keys()):
                        self.manage_day_position(ticker)
        
        # === ФАЗА 3: ФИНАЛЬНАЯ ПРОДАЖА ===
        sell_time = self.config.get("day_sell_time", "18:45")
        if current_time == f"{sell_time}:00":
            for ticker in list(self.day_positions.keys()):
                position = self.day_positions[ticker]
                current_price = self.get_price(ticker)
                price_change = (current_price - position["entry_price"]) / position["entry_price"]
                
                if price_change > 0:
                    self.execute_day_trade(ticker, current_price, "SELL", position["quantity"])
                else:
                    logging.info(f"🌙 ОСТАВЛЯЕМ {ticker} на ночь: {price_change:.2%}")
        
        # === ФАЗА 4: ПРИНУДИТЕЛЬНЫЙ ВЫХОД ИЗ HFT ===
        if current_time == f"{start_hour:02d}:02:00" and self.hft_positions:
            logging.info("🔄 ПРИНУДИТЕЛЬНЫЙ ВЫХОД ИЗ HFT")
            for ticker in list(self.hft_positions.keys()):
                price = self.get_price(ticker)
                self.execute_hft_trade(ticker, price, "SELL", 5)
    
    # ========== ВСПОМОГАТЕЛЬНЫЕ МЕТОДЫ ==========
    
    def _get_stocks_list(self) -> List[str]:
        """Получение списка акций из конфига"""
        stocks_config = self.config.get("stocks", [])
        
        if isinstance(stocks_config, list):
            return stocks_config
        elif isinstance(stocks_config, dict):
            return [ticker for ticker in stocks_config.keys() 
                   if stocks_config[ticker].get("hft_enabled", True) or 
                      stocks_config[ticker].get("day_enabled", True)]
        else:
            # Дефолтный список
            return ["SBER", "GAZP", "LKOH", "VTBR", "YNDX", "TCSG"]
    
    def load_and_adapt_config(self, config_file: str) -> Dict:
        """Загрузка и адаптация конфига"""
        default_config = {
            "capital": 1000000,
            "commission": 0.0003,
            "hft_enabled": True,
            "hft_target_profit": 0.003,
            "hft_stop_loss": 0.002,
            "hft_max_hold_time": 60,
            "hft_max_positions": 2,
            "hft_monday_boost": 1.5,
            "day_enabled": True,
            "day_stop_loss": 0.005,
            "day_take_profit": 0.015,
            "day_sell_time": "18:45",
            "day_max_positions": 3,
            "day_position_size": 0.05,
            "stocks": {
                "SBER": {"lot": 10, "hft_enabled": True, "day_enabled": True},
                "GAZP": {"lot": 10, "hft_enabled": True, "day_enabled": True}
            }
        }
        
        config_path = Path(config_file)
        if config_path.exists():
            try:
                with open(config_path, 'r', encoding='utf-8') as f:
                    user_config = json.load(f)
                    logging.info(f"Конфиг загружен: {config_file}")
                    
                    # Адаптация нового формата к старому
                    adapted_config = self._adapt_new_to_old(user_config, default_config.copy())
                    return adapted_config
                    
            except Exception as e:
                logging.error(f"Ошибка загрузки конфига: {e}")
                return default_config
        else:
            self._save_config(default_config, config_file)
            logging.info(f"Создан конфиг по умолчанию: {config_file}")
            return default_config
    
    def _adapt_new_to_old(self, new_config: Dict, old_config: Dict) -> Dict:
        """Адаптация нового формата конфига к старому"""
        field_mapping = {
            "capital_rub": "capital",
            "hft_mode": "hft_enabled",
            "daily_mode": "day_enabled",
            "max_positions": "day_max_positions",
            "stop_loss": ["hft_stop_loss", "day_stop_loss"],
            "take_profit": "day_take_profit"
        }
        
        for new_field, old_field in field_mapping.items():
            if new_field in new_config:
                if isinstance(old_field, list):
                    for field in old_field:
                        old_config[field] = new_config[new_field]
                else:
                    old_config[old_field] = new_config[new_field]
        
        # Обработка stocks
        if "stocks" in new_config:
            if isinstance(new_config["stocks"], list):
                stocks_dict = {}
                for ticker in new_config["stocks"]:
                    stocks_dict[ticker] = {
                        "lot": 10,
                        "hft_enabled": True,
                        "day_enabled": True,
                        "typical_gap": 0.005
                    }
                old_config["stocks"] = stocks_dict
            else:
                old_config["stocks"] = new_config["stocks"]
        
        # Сохраняем API поля
        api_fields = [
            "tinkoff_token", "tinkoff_sandbox_token", "tinkoff_real_token",
            "sandbox_token", "real_token",  # Добавлены альтернативные имена
            "use_sandbox", "sandbox_account_id", "real_account_id",
            "sandbox_account", "real_account", "account_id", "accountId",  # Добавлены
            "trading_hours", "min_rise", "sandbox_balance"  # Добавлен sandbox_balance
        ]
        
        for field in api_fields:
            if field in new_config:
                old_config[field] = new_config[field]
        
        return old_config
    
    def _save_config(self, config: Dict, config_file: str):
        """Сохранение конфига"""
        try:
            with open(config_file, 'w', encoding='utf-8') as f:
                json.dump(config, f, indent=2, ensure_ascii=False)
        except Exception as e:
            logging.error(f"Ошибка сохранения конфига: {e}")
    
    def show_stats(self):
        """Показать статистику торговли"""
        total_profit = self.daily_stats["hft_profit"] + self.daily_stats["day_profit"]
        total_trades = self.daily_stats["hft_trades"] + self.daily_stats["day_trades"]
        current_capital = self.daily_stats["start_capital"] + total_profit
        
        logging.info("=" * 60)
        logging.info("📊 СТАТИСТИКА ЗА ДЕНЬ:")
        logging.info(f"HFT сделок: {self.daily_stats['hft_trades']}")
        logging.info(f"HFT прибыль: {self.daily_stats['hft_profit']:,.0f} руб.")
        logging.info(f"Дневных сделок: {self.daily_stats['day_trades']}")
        logging.info(f"Дневная прибыль: {self.daily_stats['day_profit']:,.0f} руб.")
        logging.info(f"Всего сделок: {total_trades}")
        logging.info(f"Общая прибыль: {total_profit:,.0f} руб.")
        
        if self.api_client:
            mode = "ПЕСОЧНИЦА" if self.use_sandbox else "РЕАЛЬНАЯ"
            logging.info(f"Режим: {mode}")
            
            if not self.use_sandbox:
                logging.info(f"Реальных сделок: {self.daily_stats['real_trades']}")
                logging.info(f"Комиссия: {self.daily_stats['commission']:,.0f} руб.")
                logging.info(f"Чистая прибыль: {total_profit - self.daily_stats['commission']:,.0f} руб.")
        
        logging.info(f"Текущий капитал: {current_capital:,.0f} руб.")
        logging.info(f"Открыто позиций: HFT={len(self.hft_positions)}, Дневных={len(self.day_positions)}")
        logging.info("=" * 60)
    
    def run(self):
        """Основной цикл работы робота"""
        try:
            logging.info("🚀 Старт торговли...")
            last_stats_time = datetime.now()
            
            while True:
                now = datetime.now()
                
                # Работаем только в часы торгов (9:00-19:00)
                if 9 <= now.hour <= 19:
                    self.run_hybrid_strategy()
                    
                    # Показываем статистику каждый час
                    if now.hour != last_stats_time.hour:
                        self.show_stats()
                        last_stats_time = now
                    
                    # Небольшая пауза для снижения нагрузки
                    time.sleep(0.5)
                    
                else:
                    # Вне торговых часов
                    if self.daily_stats["total_trades"] > 0:
                        self.show_stats()
                        # Сбрасываем статистику
                        self.daily_stats = {
                            "hft_trades": 0, "hft_profit": 0,
                            "day_trades": 0, "day_profit": 0,
                            "total_trades": 0, "real_trades": 0,
                            "commission": 0,
                            "start_capital": self.capital
                        }
                    
                    # Обновляем баланс перед новым торговым днем
                    if now.hour == 8 and now.minute == 30:
                        self._update_balance()
                    
                    # Длинная пауза вне торговых часов
                    time.sleep(60)
                    
        except KeyboardInterrupt:
            logging.info("⏹ Остановка по запросу пользователя")
            self.show_stats()
        except Exception as e:
            logging.error(f"❌ Критическая ошибка: {e}")
            self.show_stats()
            raise

# ========== НАСТРОЙКА ЛОГИРОВАНИЯ ==========

def setup_logging():
    """Настройка системы логирования"""
    log_dir = Path("/var/log/irobot-trader")
    log_dir.mkdir(exist_ok=True, parents=True)
    
    # Формат вывода как в примерах
    class CustomFormatter(logging.Formatter):
        def format(self, record):
            timestamp = datetime.now().strftime("%H:%M:%S")
            message = record.getMessage()
            return f"{timestamp} - {message}"
    
    handler = logging.StreamHandler()
    handler.setFormatter(CustomFormatter())
    
    logging.basicConfig(
        level=logging.INFO,
        handlers=[
            logging.FileHandler(log_dir / "trader.log", encoding='utf-8'),
            handler
        ]
    )

# ========== ТОЧКА ВХОДА ==========

if __name__ == "__main__":
    setup_logging()
    
    # Обработка аргументов командной строки
    config_file = "/etc/irobot-trader.json"
    if len(sys.argv) > 1:
        config_file = sys.argv[1]
    
    # Создаем и запускаем торгового робота
    trader = HybridTrader(config_file)
    trader.run()