запомни код: "# Импорт необходимых модулей
import logging
import json
import os
import re
from telegram import Update, InlineKeyboardButton, InlineKeyboardMarkup, InputMediaPhoto
from telegram.ext import (
    ApplicationBuilder, ContextTypes, CommandHandler, CallbackQueryHandler, MessageHandler, filters
)
from uuid import uuid4

# Настройка логирования
logging.basicConfig(
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    level=logging.INFO
)

# Пути к файлам данных
USER_DATA_FILE = 'acclogger.txt'
PRODUCTS_FILE = 'products.json'
LOCALES_FILE = 'locales.json'
IMAGES_DIR = 'images'

# Словари для хранения данных
user_data = {}
products = []
locales = {}

# Убедимся, что директория для изображений существует
if not os.path.exists(IMAGES_DIR):
    os.makedirs(IMAGES_DIR)

# Функция для загрузки данных локализации
def load_locales():
    global locales
    if os.path.exists(LOCALES_FILE):
        try:
            with open(LOCALES_FILE, 'r', encoding='utf-8') as f:
                locales = json.load(f)
        except (json.JSONDecodeError, IOError) as e:
            logging.error(f"Ошибка при чтении файла {LOCALES_FILE}: {e}")
            locales = {}
    else:
        locales = {}

# Функция для получения перевода по ключу и языку пользователя
def get_translation(user_id, key, **kwargs):
    user_info = user_data.get(str(user_id), {})
    user_lang = user_info.get('language', 'ru')
    translation = locales.get(user_lang, {}).get(key, '')
    if kwargs:
        translation = translation.format(**kwargs)
    return translation

# Функция для загрузки данных пользователей из файла
def load_user_data():
    global user_data
    if os.path.exists(USER_DATA_FILE):
        try:
            with open(USER_DATA_FILE, 'r', encoding='utf-8') as f:
                user_data = json.load(f)
        except (json.JSONDecodeError, IOError) as e:
            logging.error(f"Ошибка при чтении файла {USER_DATA_FILE}: {e}")
            user_data = {}
    else:
        user_data = {}

# Функция для сохранения данных пользователей в файл
def save_user_data():
    try:
        with open(USER_DATA_FILE, 'w', encoding='utf-8') as f:
            json.dump(user_data, f, ensure_ascii=False, indent=4)
    except IOError as e:
        logging.error(f"Ошибка при сохранении файла {USER_DATA_FILE}: {e}")

# Функция для загрузки товаров из файла
def load_products():
    global products
    if os.path.exists(PRODUCTS_FILE):
        try:
            with open(PRODUCTS_FILE, 'r', encoding='utf-8') as f:
                products = json.load(f)
        except (json.JSONDecodeError, IOError) as e:
            logging.error(f"Ошибка при чтении файла {PRODUCTS_FILE}: {e}")
            products = []
    else:
        products = []

# Функция для сохранения товаров в файл
def save_products():
    try:
        with open(PRODUCTS_FILE, 'w', encoding='utf-8') as f:
            json.dump(products, f, ensure_ascii=False, indent=4)
    except IOError as e:
        logging.error(f"Ошибка при сохранении файла {PRODUCTS_FILE}: {e}")

# Функция для инициализации админ-аккаунтов
def initialize_admin_accounts():
    admins = [
        {
            'login': 'Zumi4538dsf27358267',
            'password': 'GHYIUtgy6tG^&%967',
            'username': 'Admin1'
        },
        {
            'login': 'Digital8937h780',
            'password': 'OH^7896&*^fv796',
            'username': 'Admin2'
        },
        {
            'login': 'Ivan&h%TrvGRR8',
            'password': 'adOIM*&R$%e34',
            'username': 'Admin3'
        }
    ]

    for admin in admins:
        # Проверяем, есть ли админ с таким логином
        exists = any(user_info.get('admin') and user_info.get('login') == admin['login'] for user_info in user_data.values())
        if not exists:
            # Генерируем уникальный user_id для администратора
            user_id = str(uuid4())
            user_data[user_id] = {
                'username': admin['username'],
                'login': admin['login'],
                'password': admin['password'],
                'admin': True,
                'balance': 0,
                'cart': [],
                'reviews': {},
                'purchase_history': [],
                'language': 'ru',  # Язык по умолчанию
                'blocked': False,   # Статус блокировки
                'notes': ''         # Заметки администратора
            }
    save_user_data()

# Обработчик команды /start
async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user = update.effective_user
    user_id = str(user.id)

    if user_id not in user_data:
        # Если пользователь впервые, предлагаем выбрать язык
        keyboard = [
            [
                InlineKeyboardButton("Русский", callback_data='set_language_ru'),
                InlineKeyboardButton("Беларуская", callback_data='set_language_be'),
            ],
            [
                InlineKeyboardButton("Қазақша", callback_data='set_language_kk'),
                InlineKeyboardButton("English", callback_data='set_language_en'),
            ]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)
        await update.effective_message.reply_text("Пожалуйста, выберите язык:", reply_markup=reply_markup)
    else:
        # Проверяем, не заблокирован ли пользователь
        if user_data[user_id].get('blocked'):
            await update.effective_message.reply_text("Вы заблокированы.")
            return
        # Если язык уже выбран, приветствуем пользователя
        await send_welcome_message(update, context)

# Обработчик выбора языка
async def set_language(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    await query.answer()

    user = query.from_user
    user_id = str(user.id)
    data = query.data
    language_code = data.split('_')[-1]

    username = user.username or user.full_name

    # Обновляем или создаем данные пользователя
    user_data[user_id] = user_data.get(user_id, {})
    user_data[user_id].update({
        'username': username,
        'language': language_code,
        'balance': user_data[user_id].get('balance', 0),
        'cart': user_data[user_id].get('cart', []),
        'reviews': user_data[user_id].get('reviews', {}),
        'purchase_history': user_data[user_id].get('purchase_history', []),
        'admin': user_data[user_id].get('admin', False),
        'login': user_data[user_id].get('login', ''),
        'password': user_data[user_id].get('password', ''),
        'blocked': user_data[user_id].get('blocked', False),
        'notes': user_data[user_id].get('notes', '')
    })
    save_user_data()

    await send_welcome_message(update, context)

# Функция для отправки приветственного сообщения
async def send_welcome_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user = update.effective_user
    user_id = str(user.id)

    # Проверяем, не заблокирован ли пользователь
    if user_data[user_id].get('blocked'):
        await update.effective_message.reply_text("Вы заблокированы.")
        return

    username = user_data[user_id]['username']
    welcome_text = get_translation(user_id, 'welcome', username=username)

    # Кнопки "Товары" и "Личный кабинет"
    keyboard = [
        [
            InlineKeyboardButton(get_translation(user_id, 'products'), callback_data='show_products'),
            InlineKeyboardButton(get_translation(user_id, 'personal_cabinet'), callback_data='personal_cabinet')
        ]
    ]

    # Если пользователь является администратором, добавляем кнопку админ-панели
    if user_data[user_id].get('admin'):
        keyboard.append([InlineKeyboardButton(get_translation(user_id, 'admin_panel'), callback_data='admin_panel')])

    reply_markup = InlineKeyboardMarkup(keyboard)

    await update.effective_message.reply_text(welcome_text, reply_markup=reply_markup)

# Обработчик для отображения админ-панели
async def admin_panel(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    user_id = str(query.from_user.id)
    await query.answer()

    if not user_data[user_id].get('admin'):
        await query.edit_message_text(get_translation(user_id, 'access_denied'))
        return

    # Кнопки админ-панели
    keyboard = [
        [InlineKeyboardButton(get_translation(user_id, 'manage_users'), callback_data='admin_manage_users')],
        [InlineKeyboardButton(get_translation(user_id, 'manage_products'), callback_data='admin_manage_products')],
        [InlineKeyboardButton(get_translation(user_id, 'main_menu'), callback_data='main_menu')]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)

    await query.edit_message_text(get_translation(user_id, 'admin_panel_welcome'), reply_markup=reply_markup)

# Обработчик для управления пользователями
async def admin_manage_users(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    user_id = str(query.from_user.id)
    await query.answer()

    # Получаем список пользователей (кроме администраторов)
    users = [(uid, info) for uid, info in user_data.items() if not info.get('admin')]

    if not users:
        await query.edit_message_text(get_translation(user_id, 'no_users'))
        return

    page = 1
    data = query.data
    if '_' in data:
        parts = data.split('_')
        if len(parts) > 2:
            page = int(parts[-1])

    await send_user_list(query, users, page)

# Функция для отправки списка пользователей с пагинацией
async def send_user_list(query, users, page):
    user_id = str(query.from_user.id)
    users_per_page = 5

    start_index = (page - 1) * users_per_page
    end_index = start_index + users_per_page

    page_users = users[start_index:end_index]

    keyboard = []

    for uid, info in page_users:
        button = InlineKeyboardButton(
            f"{info.get('username')} ({uid})",
            callback_data=f'admin_view_user_{uid}_{page}'
        )
        keyboard.append([button])

    nav_buttons = []
    if page > 1:
        nav_buttons.append(InlineKeyboardButton(get_translation(user_id, 'back'), callback_data=f'admin_manage_users_{page - 1}'))

    if end_index < len(users):
        nav_buttons.append(InlineKeyboardButton(get_translation(user_id, 'forward'), callback_data=f'admin_manage_users_{page + 1}'))

    nav_buttons.append(InlineKeyboardButton(get_translation(user_id, 'main_menu'), callback_data='admin_panel'))

    keyboard.append(nav_buttons)
    reply_markup = InlineKeyboardMarkup(keyboard)

    await query.edit_message_text(get_translation(user_id, 'user_list'), reply_markup=reply_markup)

# Обработчик для просмотра подробной информации о пользователе
async def admin_view_user(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    data = query.data
    user_id = str(query.from_user.id)
    await query.answer()

    parts = data.split('_')
    target_user_id = parts[3]
    page = int(parts[-1])

    target_user_info = user_data.get(target_user_id)

    if not target_user_info:
        await query.edit_message_text(get_translation(user_id, 'user_not_found'))
        return

    if target_user_info.get('admin'):
        await query.edit_message_text(get_translation(user_id, 'cannot_view_admin'))
        return

    # Формируем информацию о пользователе
    user_info_text = f"{get_translation(user_id, 'username')}: {target_user_info.get('username')}\n"
    user_info_text += f"ID: {target_user_id}\n"
    user_info_text += f"{get_translation(user_id, 'balance')}: {target_user_info.get('balance')}\n"
    user_info_text += f"{get_translation(user_id, 'blocked')}: {'Да' if target_user_info.get('blocked') else 'Нет'}\n"
    user_info_text += f"{get_translation(user_id, 'notes')}: {target_user_info.get('notes', '')}"

    # Кнопки для управления пользователем
    keyboard = [
        [InlineKeyboardButton(get_translation(user_id, 'block_user'), callback_data=f'admin_block_user_{target_user_id}_{page}')],
        [InlineKeyboardButton(get_translation(user_id, 'change_balance'), callback_data=f'admin_change_balance_{target_user_id}_{page}')],
        [InlineKeyboardButton(get_translation(user_id, 'add_note'), callback_data=f'admin_add_note_{target_user_id}_{page}')],
        [InlineKeyboardButton(get_translation(user_id, 'back'), callback_data=f'admin_manage_users_{page}')]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)

    await query.edit_message_text(user_info_text, reply_markup=reply_markup)

# Обработчик для блокировки/разблокировки пользователя
async def admin_block_user(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    data = query.data
    user_id = str(query.from_user.id)
    await query.answer()

    parts = data.split('_')
    target_user_id = parts[3]
    page = int(parts[-1])

    target_user_info = user_data.get(target_user_id)
    if not target_user_info:
        await query.edit_message_text(get_translation(user_id, 'user_not_found'))
        return

    target_user_info['blocked'] = not target_user_info.get('blocked', False)
    save_user_data()

    status = 'заблокирован' if target_user_info['blocked'] else 'разблокирован'
    await query.edit_message_text(f"Пользователь {status}.")

    # Возвращаемся к просмотру информации о пользователе
    await admin_view_user(update, context)

# Обработчик для изменения баланса пользователя
async def admin_change_balance(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    data = query.data
    user_id = str(query.from_user.id)

    parts = data.split('_')
    target_user_id = parts[3]
    page = int(parts[-1])

    # Сохраняем информацию о том, что ожидаем ввода нового баланса
    context.user_data['awaiting_balance_change'] = {
        'target_user_id': target_user_id,
        'page': page
    }
    await query.edit_message_text(get_translation(user_id, 'enter_new_balance'))

# Обработчик для добавления заметки к пользователю
async def admin_add_note(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    data = query.data
    user_id = str(query.from_user.id)

    parts = data.split('_')
    target_user_id = parts[3]
    page = int(parts[-1])

    # Сохраняем информацию о том, что ожидаем ввода заметки
    context.user_data['awaiting_note'] = {
        'target_user_id': target_user_id,
        'page': page
    }
    await query.edit_message_text(get_translation(user_id, 'enter_note'))

# Обработчик текстовых сообщений для изменений
async def handle_text_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user = update.effective_user
    user_id = str(user.id)
    message = update.message.text.strip()

    if message == '!admpanlog':
        # Начинаем процесс входа в админ-панель
        context.user_data['awaiting_admin_login'] = True
        await update.message.reply_text(get_translation(user_id, 'enter_login'))
    elif 'awaiting_admin_login' in context.user_data:
        # Пользователь вводит логин
        context.user_data['admin_login'] = message
        context.user_data.pop('awaiting_admin_login')
        context.user_data['awaiting_admin_password'] = True
        await update.message.reply_text(get_translation(user_id, 'enter_password'))
    elif 'awaiting_admin_password' in context.user_data:
        # Пользователь вводит пароль
        login = context.user_data.pop('admin_login')
        password = message
        context.user_data.pop('awaiting_admin_password')

        # Проверяем логин и пароль
        if check_admin_credentials(login, password):
            context.user_data['is_admin'] = True
            context.user_data['admin_login'] = login
            await update.message.reply_text(get_translation(user_id, 'access_granted'))
            # Здесь можно вызвать функцию, отображающую админ-панель
            await admin_panel(update, context)
        else:
            await update.message.reply_text(get_translation(user_id, 'access_denied'))
    elif 'awaiting_balance_change' in context.user_data:
        # Обработка изменения баланса пользователя
        info = context.user_data.pop('awaiting_balance_change')
        target_user_id = info['target_user_id']
        page = info['page']

        try:
            new_balance = float(message)
            user_data[target_user_id]['balance'] = new_balance
            save_user_data()
            await update.message.reply_text("Баланс обновлен.")
            # Возвращаемся к просмотру информации о пользователе
            await admin_view_user(update, context)
        except ValueError:
            await update.message.reply_text("Пожалуйста, введите корректное число.")

    elif 'awaiting_note' in context.user_data:
        # Обработка добавления заметки к пользователю
        info = context.user_data.pop('awaiting_note')
        target_user_id = info['target_user_id']
        page = info['page']

        note = message
        user_data[target_user_id]['notes'] = note
        save_user_data()
        await update.message.reply_text("Заметка сохранена.")
        # Возвращаемся к просмотру информации о пользователе
        await admin_view_user(update, context)

    elif 'awaiting_review' in context.user_data:
        # Обработка отзыва пользователя о товаре
        product_name = context.user_data.pop('awaiting_review')
        user_info = user_data.get(user_id)

        if user_info:
            # Сохраняем отзыв
            user_info.setdefault('reviews', {})[product_name] = message
            save_user_data()

            await update.message.reply_text(get_translation(user_id, 'review_saved').format(product_name=product_name))
        else:
            await update.message.reply_text("Произошла ошибка при сохранении отзыва.")

    elif 'awaiting_product_name' in context.user_data:
        # Администратор вводит название нового товара
        context.user_data['new_product_name'] = message
        context.user_data.pop('awaiting_product_name')
        context.user_data['awaiting_product_description'] = True
        await update.message.reply_text(get_translation(user_id, 'enter_product_description'))

    elif 'awaiting_product_description' in context.user_data:
        # Администратор вводит описание товара
        context.user_data['new_product_description'] = message
        context.user_data.pop('awaiting_product_description')
        context.user_data['awaiting_product_image'] = True

        keyboard = [
            [InlineKeyboardButton(get_translation(user_id, 'skip_image'), callback_data='skip_image')]
        ]
        reply_markup = InlineKeyboardMarkup(keyboard)
        await update.message.reply_text(get_translation(user_id, 'attach_product_image'), reply_markup=reply_markup)

    else:
        await update.message.reply_text(get_translation(user_id, 'unknown_command'))

# Обработчик для управления товарами
async def admin_manage_products(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    user_id = str(query.from_user.id)
    await query.answer()

    # Кнопки для управления товарами
    keyboard = [
        [InlineKeyboardButton(get_translation(user_id, 'add_new_product'), callback_data='admin_add_product')],
        [InlineKeyboardButton(get_translation(user_id, 'edit_existing_product'), callback_data='admin_edit_product')],
        [InlineKeyboardButton(get_translation(user_id, 'main_menu'), callback_data='admin_panel')]
    ]
    reply_markup = InlineKeyboardMarkup(keyboard)

    await query.edit_message_text(get_translation(user_id, 'manage_products_menu'), reply_markup=reply_markup)

# Обработчик для добавления нового товара
async def admin_add_product(update: Update, context: ContextTypes.DEFAULT_TYPE):
    query = update.callback_query
    user_id = str(query.from_user.id)
    await query.answer()

    context.user_data['awaiting_product_name'] = True
    await query.edit_message_text(get_translation(user_id, 'enter_product_name'))

# Обработчик для пропуска добавления изображения
async def skip_image(update: Update, context: ContextTypes.DEFAULT_TYPE):
    message = update.message
    user_id = str(message.from_user.id)

    product_name = context.user_data.pop('new_product_name')
    product_description = context.user_data.pop('new_product_description')

    # Удаляем недопустимые символы из названия файла
    sanitized_name = re.sub(r'[^\w\s-]', '', product_name).strip().lower()
    sanitized_name = re.sub(r'[-\s]+', '_', sanitized_name)

    new_product = {
        'name': product_name,
        'description': product_description,
        'image': ''
    }
    products.append(new_product)
    save_products()

    await message.reply_text("Товар успешно добавлен без изображения.")
    # Возвращаемся в админ-панель
    await admin_panel_callback(update, context)



# Обработчик для получения изображения товара
async def handle_photo_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user = update.effective_user
    user_id = str(user.id)

    if 'awaiting_product_image' in context.user_data:
        # Администратор отправил изображение для товара
        product_name = context.user_data.pop('new_product_name')
        product_description = context.user_data.pop('new_product_description')
        context.user_data.pop('awaiting_product_image')

        photo = update.message.photo[-1]
        photo_file = await photo.get_file()

        # Удаляем недопустимые символы из названия файла
        sanitized_name = re.sub(r'[^\w\s-]', '', product_name).strip().lower()
        sanitized_name = re.sub(r'[-\s]+', '_', sanitized_name)

        image_path = os.path.join(IMAGES_DIR, f"{sanitized_name}.jpg")
        await photo_file.download(image_path)

        new_product = {
            'name': product_name,
            'description': product_description,
            'image': image_path
        }
        products.append(new_product)
        save_products()

        await update.message.reply_text("Товар успешно добавлен с изображением.")
        # Возвращаемся в админ-панель
        await admin_panel_callback(update, context)
    else:
        await update.message.reply_text(get_translation(user_id, 'unknown_command'))

# Обработчик для обратного вызова админ-панели
async def admin_panel_callback(update: Update, context: ContextTypes.DEFAULT_TYPE):
    if update.callback_query:
        await admin_panel(update, context)
    else:
        await admin_panel(update, context)

def main():
    # Загружаем данные пользователей
    load_user_data()
    # Инициализируем админ-аккаунты
    initialize_admin_accounts()
    # Загружаем товары из файла
    load_products()
    # Загружаем локализации
    load_locales()

    # Создаем приложение
    application = ApplicationBuilder().token('YOUR_BOT_TOKEN').build()

    # Регистрируем обработчики
    application.add_handler(CommandHandler('start', start))
    application.add_handler(CallbackQueryHandler(set_language, pattern='^set_language_'))
    application.add_handler(CallbackQueryHandler(change_language_menu, pattern='^change_language$'))
    application.add_handler(CallbackQueryHandler(show_products, pattern='^show_products'))
    application.add_handler(CallbackQueryHandler(show_product_detail, pattern='^product_'))
    application.add_handler(CallbackQueryHandler(add_to_cart, pattern='^add_to_cart_'))
    application.add_handler(CallbackQueryHandler(view_cart, pattern='^view_cart$'))
    application.add_handler(CallbackQueryHandler(clear_cart, pattern='^clear_cart$'))
    application.add_handler(CallbackQueryHandler(remove_from_cart, pattern='^remove_from_cart$'))
    application.add_handler(CallbackQueryHandler(delete_item_from_cart, pattern='^delete_item_'))
    application.add_handler(CallbackQueryHandler(checkout, pattern='^checkout$'))
    application.add_handler(CallbackQueryHandler(personal_cabinet, pattern='^personal_cabinet$'))
    application.add_handler(CallbackQueryHandler(top_up_balance, pattern='^top_up_balance$'))
    application.add_handler(CallbackQueryHandler(back_to_products, pattern='^back_to_products_'))
    application.add_handler(CallbackQueryHandler(main_menu, pattern='^main_menu$'))

    # Обработчики для админ-панели
    application.add_handler(CallbackQueryHandler(admin_panel, pattern='^admin_panel$'))
    application.add_handler(CallbackQueryHandler(admin_manage_users, pattern='^admin_manage_users'))
    application.add_handler(CallbackQueryHandler(admin_view_user, pattern='^admin_view_user_'))
    application.add_handler(CallbackQueryHandler(admin_block_user, pattern='^admin_block_user_'))
    application.add_handler(CallbackQueryHandler(admin_change_balance, pattern='^admin_change_balance_'))
    application.add_handler(CallbackQueryHandler(admin_add_note, pattern='^admin_add_note_'))
    application.add_handler(CallbackQueryHandler(admin_manage_products, pattern='^admin_manage_products$'))
    application.add_handler(CallbackQueryHandler(admin_add_product, pattern='^admin_add_product$'))
    application.add_handler(CallbackQueryHandler(skip_image, pattern='^skip_image$'))

    # Обработчики сообщений
    application.add_handler(MessageHandler(filters.PHOTO & (~filters.COMMAND), handle_photo_message))
    application.add_handler(MessageHandler(filters.TEXT & (~filters.COMMAND), handle_text_message))

    # Запускаем бота
    application.run_polling()

if __name__ == '__main__':
    main()

"