FunPayCardinal

class PluginData:
    def __init__(self, name: str, version: str, desc: str, 
                 credentials: str, uuid: str, path: str, 
                 plugin: ModuleType, settings_page: bool, 
                 delete_handler: Callable | None, enabled: bool):
        self.name = name                    # Название плагина
        self.version = version              # Версия плагина
        self.description = desc             # Описание плагина
        self.credits = credentials          # Авторы плагина
        self.uuid = uuid                    # UUID плагина
        self.path = path                    # Путь до файла плагина
        self.plugin = plugin                # Экземпляр модуля плагина
        self.settings_page = settings_page  # Есть ли страница настроек
        self.commands = {}                  # Telegram команды плагина
        self.delete_handler = delete_handler # Обработчик удаления
        self.enabled = enabled              # Включен ли плагин

def load_plugin(from_file: str) -> tuple:
    """
    Создает модуль из файла-плагина и получает необходимые поля.
    """
    # Создание спецификации модуля
    spec = importlib.util.spec_from_file_location(
        f"plugins.{from_file[:-3]}", 
        f"plugins/{from_file}"
    )
    
    # Создание модуля из спецификации
    plugin = importlib.util.module_from_spec(spec)
    sys.modules[f"plugins.{from_file[:-3]}"] = plugin
    
    # Выполнение кода модуля
    spec.loader.exec_module(plugin)
    
    # Извлечение обязательных полей
    fields = ["NAME", "VERSION", "DESCRIPTION", "CREDITS", 
              "SETTINGS_PAGE", "UUID", "BIND_TO_DELETE"]
    result = {}
    
    for field in fields:
        try:
            value = getattr(plugin, field)
        except AttributeError:
            raise FieldNotExistsError(field, from_file)
        result[field] = value
        
    return plugin, result

@staticmethod
def is_uuid_valid(uuid: str) -> bool:
    """
    Проверяет, является ли UUID плагина валидным.
    """
    try:
        uuid_obj = UUID(uuid, version=4)
    except ValueError:
        return False
    return str(uuid_obj) == uuid

# Проверка уникальности UUID
if data["UUID"] in self.plugins:
    logger.error(f"UUID {data['UUID']} уже зарегистрирован для плагина {data['NAME']}")
    continue

# Создание экземпляра PluginData
plugin_data = PluginData(
    name=data["NAME"],
    version=data["VERSION"], 
    desc=data["DESCRIPTION"],
    credentials=data["CREDITS"],
    uuid=data["UUID"],
    path=f"plugins/{file}",
    plugin=plugin,
    settings_page=data["SETTINGS_PAGE"],
    delete_handler=data["BIND_TO_DELETE"],
    enabled=False if data["UUID"] in self.disabled_plugins else True
)

# Добавление в реестр плагинов
self.plugins[data["UUID"]] = plugin_data

def add_handlers_from_plugin(self, plugin, uuid: str | None = None):
    """
    Добавляет обработчики из плагина и присваивает каждому UUID плагина.
    """
    # Список переменных с обработчиками
    handler_vars = [
        "BIND_TO_PRE_INIT", "BIND_TO_INIT", "BIND_TO_POST_INIT",
        "BIND_TO_PRE_START", "BIND_TO_START", "BIND_TO_POST_START", 
        "BIND_TO_PRE_STOP", "BIND_TO_STOP", "BIND_TO_POST_STOP",
        "BIND_TO_NEW_MESSAGE", "BIND_TO_ORDER_CONFIRMED", 
        "BIND_TO_ORDER_COMPLETED", "BIND_TO_REVIEW"
    ]
    
    for var_name in handler_vars:
        try:
            functions = getattr(plugin, var_name)
        except AttributeError:
            continue
            
        # Присваиваем UUID каждой функции
        for func in functions:
            func.plugin_uuid = uuid
            
        # Добавляем в соответствующий список обработчиков
        self.handler_bind_var_names[var_name].extend(functions)
        
    logger.info(f"Обработчики зарегистрированы для {plugin.__name__}")

# Настройки по умолчанию
DEFAULT_CONFIG = {
    # Основные настройки
    "enabled": True,                    # Включен ли плагин
    "debug_mode": False,               # Режим отладки
    "log_level": "INFO",               # Уровень логирования
    
    # Настройки автоответов
    "auto_reply_enabled": True,        # Включены ли автоответы
    "reply_delay_min": 1,              # Минимальная задержка (сек)
    "reply_delay_max": 5,              # Максимальная задержка (сек)
    
    # Настройки времени работы
    "work_hours": {
        "enabled": False,              # Ограничение по времени
        "start": "09:00",              # Начало работы
        "end": "18:00",                # Конец работы
        "timezone": "Europe/Moscow"    # Часовой пояс
    },
    
    # Настройки уведомлений
    "notifications": {
        "telegram_enabled": True,      # Уведомления в Telegram
        "email_enabled": False,        # Email уведомления
        "webhook_url": None            # URL для webhook
    },
    
    # Настройки производительности
    "performance": {
        "max_concurrent_requests": 10, # Макс. одновременных запросов
        "request_timeout": 30,         # Таймаут запроса (сек)
        "retry_attempts": 3,           # Количество повторов
        "cache_ttl": 300              # Время жизни кэша (сек)
    }
}

import json
import os
from threading import Lock
from typing import Dict, Any

# Файл конфигурации
CONFIG_FILE = f"plugins/{NAME.lower().replace(' ', '_')}_config.json"
config_lock = Lock()

def load_config() -> Dict[str, Any]:
    """
    Загружает конфигурацию плагина из файла
    """
    global config
    
    try:
        if os.path.exists(CONFIG_FILE):
            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
                loaded_config = json.load(f)
                # Объединяем с настройками по умолчанию
                config = {**DEFAULT_CONFIG, **loaded_config}
                logger.info("Конфигурация плагина загружена")
        else:
            config = DEFAULT_CONFIG.copy()
            save_config()
            logger.info("Создана конфигурация по умолчанию")
    except Exception as e:
        logger.error(f"Ошибка при загрузке конфигурации: {e}")
        config = DEFAULT_CONFIG.copy()
    
    return config

def save_config():
    """
    Сохраняет текущую конфигурацию в файл
    """
    try:
        with config_lock:
            # Создаем папку plugins, если её нет
            os.makedirs("plugins", exist_ok=True)
            
            with open(CONFIG_FILE, "w", encoding="utf-8") as f:
                json.dump(config, f, ensure_ascii=False, indent=4)
                
        logger.info("Конфигурация сохранена")
    except Exception as e:
        logger.error(f"Ошибка при сохранении конфигурации: {e}")

def get_config_value(key: str, default=None):
    """
    Получает значение из конфигурации с поддержкой вложенных ключей
    """
    keys = key.split('.')
    value = config
    
    try:
        for k in keys:
            value = value[k]
        return value
    except (KeyError, TypeError):
        return default

def set_config_value(key: str, value: Any):
    """
    Устанавливает значение в конфигурации с поддержкой вложенных ключей
    """
    keys = key.split('.')
    target = config
    
    # Навигация к родительскому объекту
    for k in keys[:-1]:
        if k not in target:
            target[k] = {}
        target = target[k]
    
    # Установка значения
    target[keys[-1]] = value
    save_config()

class ConfigValidationError(Exception):
    """Ошибка валидации конфигурации"""
    pass

def validate_config(config_data: Dict[str, Any]) -> bool:
    """
    Валидирует конфигурацию плагина
    """
    try:
        # Проверка обязательных полей
        required_fields = ["enabled", "debug_mode", "log_level"]
        for field in required_fields:
            if field not in config_data:
                raise ConfigValidationError(f"Отсутствует обязательное поле: {field}")
        
        # Проверка типов данных
        if not isinstance(config_data["enabled"], bool):
            raise ConfigValidationError("Поле 'enabled' должно быть boolean")
        
        if not isinstance(config_data["debug_mode"], bool):
            raise ConfigValidationError("Поле 'debug_mode' должно быть boolean")
        
        # Проверка уровня логирования
        valid_log_levels = ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]
        if config_data["log_level"] not in valid_log_levels:
            raise ConfigValidationError(f"Недопустимый уровень логирования: {config_data['log_level']}")
        
        # Проверка настроек времени работы
        if "work_hours" in config_data:
            work_hours = config_data["work_hours"]
            if work_hours.get("enabled", False):
                import re
                time_pattern = r"^([01]?[0-9]|2[0-3]):[0-5][0-9]$"
                
                if not re.match(time_pattern, work_hours.get("start", "")):
                    raise ConfigValidationError("Некорректный формат времени начала работы")
                
                if not re.match(time_pattern, work_hours.get("end", "")):
                    raise ConfigValidationError("Некорректный формат времени окончания работы")
        
        # Проверка настроек производительности
        if "performance" in config_data:
            perf = config_data["performance"]
            
            if perf.get("max_concurrent_requests", 0) <= 0:
                raise ConfigValidationError("max_concurrent_requests должно быть положительным числом")
            
            if perf.get("request_timeout", 0) <= 0:
                raise ConfigValidationError("request_timeout должно быть положительным числом")
        
        return True
        
    except ConfigValidationError as e:
        logger.error(f"Ошибка валидации конфигурации: {e}")
        return False
    except Exception as e:
        logger.error(f"Неожиданная ошибка при валидации: {e}")
        return False

import logging
import traceback
from typing import Optional

logger = logging.getLogger("FunPayCardinal.Plugin")

class PluginLoadError(Exception):
    """Базовый класс для ошибок загрузки плагина"""
    pass

class ConfigurationError(PluginLoadError):
    """Ошибка конфигурации плагина"""
    pass

class DependencyError(PluginLoadError):
    """Ошибка зависимостей плагина"""
    pass

def safe_plugin_init():
    """
    Безопасная инициализация плагина с обработкой ошибок
    """
    try:
        # Проверка зависимостей
        check_dependencies()
        
        # Загрузка конфигурации
        config = load_config()
        validate_config(config)
        
        # Инициализация компонентов
        initialize_components()
        
        logger.info(f"Плагин {NAME} успешно инициализирован")
        
    except ConfigurationError as e:
        logger.error(f"Ошибка конфигурации плагина {NAME}: {e}")
        raise
    except DependencyError as e:
        logger.error(f"Отсутствуют зависимости для плагина {NAME}: {e}")
        raise
    except Exception as e:
        logger.error(f"Неожиданная ошибка при инициализации {NAME}: {e}")
        logger.debug(f"Трассировка ошибки: {traceback.format_exc()}")
        raise PluginLoadError(f"Не удалось инициализировать плагин: {e}")

def check_dependencies():
    """Проверка наличия необходимых зависимостей"""
    required_modules = ["requests", "json", "datetime"]
    
    for module in required_modules:
        try:
            __import__(module)
        except ImportError:
            raise DependencyError(f"Отсутствует модуль: {module}")

def initialize_components():
    """Инициализация компонентов плагина"""
    try:
        # Инициализация API клиентов
        # Подключение к базе данных
        # Настройка обработчиков
        pass
    except Exception as e:
        raise PluginLoadError(f"Ошибка инициализации компонентов: {e}")

import asyncio
from functools import wraps

def safe_message_handler(func):
    """
    Декоратор для безопасной обработки сообщений
    """
    @wraps(func)
    async def wrapper(cardinal, event, *args, **kwargs):
        try:
            return await func(cardinal, event, *args, **kwargs)
        except asyncio.TimeoutError:
            logger.warning(f"Таймаут при обработке сообщения в {func.__name__}")
        except ConnectionError as e:
            logger.error(f"Ошибка соединения в {func.__name__}: {e}")
            # Попытка переподключения
            await reconnect_if_needed()
        except ValueError as e:
            logger.error(f"Некорректные данные в {func.__name__}: {e}")
            # Отправка уведомления об ошибке
            await send_error_notification(event, str(e))
        except Exception as e:
            logger.error(f"Неожиданная ошибка в {func.__name__}: {e}")
            logger.debug(f"Трассировка: {traceback.format_exc()}")
            # Критическая ошибка - уведомляем администратора
            await notify_admin_critical_error(func.__name__, str(e))
    
    return wrapper

@safe_message_handler
async def handle_new_message(cardinal, event):
    """
    Обработчик новых сообщений с защитой от ошибок
    """
    message = event.message
    
    # Валидация входных данных
    if not message or not message.text:
        raise ValueError("Получено пустое сообщение")
    
    # Проверка длины сообщения
    if len(message.text) > 4000:
        logger.warning("Получено слишком длинное сообщение")
        return
    
    # Обработка сообщения
    response = await process_message(message.text)
    
    # Отправка ответа с повторными попытками
    await send_response_with_retry(cardinal, message.chat_id, response)

async def send_response_with_retry(cardinal, chat_id: int, text: str, max_retries: int = 3):
    """
    Отправка ответа с повторными попытками при ошибках
    """
    for attempt in range(max_retries):
        try:
            await cardinal.telegram.bot.send_message(chat_id, text)
            return
        except Exception as e:
            logger.warning(f"Попытка {attempt + 1} отправки сообщения неудачна: {e}")
            if attempt < max_retries - 1:
                await asyncio.sleep(2 ** attempt)  # Экспоненциальная задержка
            else:
                logger.error(f"Не удалось отправить сообщение после {max_retries} попыток")
                raise

import aiohttp
import asyncio
from typing import Optional, Dict, Any

class APIError(Exception):
    """Базовый класс для API ошибок"""
    def __init__(self, message: str, status_code: Optional[int] = None):
        super().__init__(message)
        self.status_code = status_code

class RateLimitError(APIError):
    """Ошибка превышения лимита запросов"""
    pass

class APIClient:
    def __init__(self, base_url: str, timeout: int = 30):
        self.base_url = base_url
        self.timeout = aiohttp.ClientTimeout(total=timeout)
        self.session: Optional[aiohttp.ClientSession] = None
    
    async def __aenter__(self):
        self.session = aiohttp.ClientSession(timeout=self.timeout)
        return self
    
    async def __aexit__(self, exc_type, exc_val, exc_tb):
        if self.session:
            await self.session.close()
    
    async def make_request(self, method: str, endpoint: str, 
                          max_retries: int = 3, **kwargs) -> Dict[str, Any]:
        """
        Выполняет HTTP запрос с обработкой ошибок и повторными попытками
        """
        url = f"{self.base_url}/{endpoint.lstrip('/')}"
        
        for attempt in range(max_retries):
            try:
                async with self.session.request(method, url, **kwargs) as response:
                    # Обработка различных статус кодов
                    if response.status == 200:
                        return await response.json()
                    elif response.status == 429:
                        # Rate limit - ждем и повторяем
                        retry_after = int(response.headers.get('Retry-After', 60))
                        logger.warning(f"Rate limit достигнут, ожидание {retry_after} секунд")
                        await asyncio.sleep(retry_after)
                        continue
                    elif response.status >= 500:
                        # Серверная ошибка - повторяем запрос
                        logger.warning(f"Серверная ошибка {response.status}, попытка {attempt + 1}")
                        if attempt < max_retries - 1:
                            await asyncio.sleep(2 ** attempt)
                            continue
                    else:
                        # Клиентская ошибка - не повторяем
                        error_text = await response.text()
                        raise APIError(f"API ошибка {response.status}: {error_text}", 
                                     response.status)
                        
            except asyncio.TimeoutError:
                logger.warning(f"Таймаут запроса к {url}, попытка {attempt + 1}")
                if attempt < max_retries - 1:
                    await asyncio.sleep(2 ** attempt)
                    continue
                else:
                    raise APIError(f"Таймаут запроса после {max_retries} попыток")
            
            except aiohttp.ClientError as e:
                logger.error(f"Ошибка клиента при запросе к {url}: {e}")
                if attempt < max_retries - 1:
                    await asyncio.sleep(2 ** attempt)
                    continue
                else:
                    raise APIError(f"Ошибка соединения: {e}")
        
        raise APIError(f"Не удалось выполнить запрос после {max_retries} попыток")

# Пример использования
async def get_user_data(user_id: int) -> Optional[Dict[str, Any]]:
    """
    Получает данные пользователя с обработкой ошибок
    """
    try:
        async with APIClient("https://api.example.com") as client:
            data = await client.make_request("GET", f"/users/{user_id}")
            return data
    except APIError as e:
        logger.error(f"Ошибка получения данных пользователя {user_id}: {e}")
        return None
    except Exception as e:
        logger.error(f"Неожиданная ошибка: {e}")
        return None

import logging
import logging.handlers
import os
from datetime import datetime

def setup_plugin_logging(plugin_name: str, log_level: str = "INFO"):
    """
    Настраивает систему логирования для плагина
    """
    # Создание логгера для плагина
    logger = logging.getLogger(f"FunPayCardinal.Plugin.{plugin_name}")
    logger.setLevel(getattr(logging, log_level.upper()))
    
    # Очистка существующих обработчиков
    logger.handlers.clear()
    
    # Создание папки для логов
    log_dir = "logs/plugins"
    os.makedirs(log_dir, exist_ok=True)
    
    # Файловый обработчик с ротацией
    log_file = f"{log_dir}/{plugin_name.lower().replace(' ', '_')}.log"
    file_handler = logging.handlers.RotatingFileHandler(
        log_file, 
        maxBytes=10*1024*1024,  # 10MB
        backupCount=5,
        encoding='utf-8'
    )
    
    # Консольный обработчик
    console_handler = logging.StreamHandler()
    
    # Форматтер для логов
    formatter = logging.Formatter(
        '%(asctime)s - %(name)s - %(levelname)s - %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S'
    )
    
    file_handler.setFormatter(formatter)
    console_handler.setFormatter(formatter)
    
    # Добавление обработчиков
    logger.addHandler(file_handler)
    logger.addHandler(console_handler)
    
    return logger

# Инициализация логгера для плагина
logger = setup_plugin_logging(NAME, get_config_value("log_level", "INFO"))

class PluginErrorReporter:
    """
    Класс для отчетности об ошибках плагина
    """
    
    def __init__(self, plugin_name: str):
        self.plugin_name = plugin_name
        self.error_count = 0
        self.last_errors = []
        self.max_stored_errors = 50
    
    def report_error(self, error: Exception, context: str = ""):
        """
        Регистрирует ошибку и отправляет уведомления при необходимости
        """
        self.error_count += 1
        
        error_info = {
            "timestamp": datetime.now().isoformat(),
            "error_type": type(error).__name__,
            "error_message": str(error),
            "context": context,
            "traceback": traceback.format_exc()
        }
        
        # Сохранение информации об ошибке
        self.last_errors.append(error_info)
        if len(self.last_errors) > self.max_stored_errors:
            self.last_errors.pop(0)
        
        # Логирование ошибки
        logger.error(f"Ошибка в контексте '{context}': {error}")
        logger.debug(f"Трассировка ошибки: {error_info['traceback']}")
        
        # Критические ошибки требуют немедленного уведомления
        if self._is_critical_error(error):
            asyncio.create_task(self._send_critical_error_notification(error_info))
    
    def _is_critical_error(self, error: Exception) -> bool:
        """Определяет, является ли ошибка критической"""
        critical_errors = (
            MemoryError,
            SystemError,
            KeyboardInterrupt,
            SystemExit
        )
        return isinstance(error, critical_errors)
    
    async def _send_critical_error_notification(self, error_info: Dict[str, Any]):
        """Отправляет уведомление о критической ошибке"""
        try:
            # Отправка уведомления администратору
            message = f"🚨 Критическая ошибка в плагине {self.plugin_name}:\n"
            message += f"Тип: {error_info['error_type']}\n"
            message += f"Сообщение: {error_info['error_message']}\n"
            message += f"Контекст: {error_info['context']}"
            
            # Здесь должна быть логика отправки уведомления
            logger.critical(f"КРИТИЧЕСКАЯ ОШИБКА: {message}")
            
        except Exception as e:
            logger.error(f"Не удалось отправить уведомление о критической ошибке: {e}")

# Глобальный репортер ошибок для плагина
error_reporter = PluginErrorReporter(NAME)