editor.py

import os
import json
import time
import tkinter as tk
from tkinter import ttk, filedialog, simpledialog, messagebox
from PIL import Image, ImageTk, ImageSequence
import shutil
import math
import random
import threading
import sys
import glob
import re
from audio import AudioProcessor
import zipfile
import tempfile
import queue
import weakref
from functools import lru_cache
import uuid
from locale_loader import tr, i18n

# Определение базовой директории
if getattr(sys, 'frozen', False):
    BASE_DIR = os.path.dirname(sys.executable)
else:
    BASE_DIR = os.path.dirname(os.path.abspath(__file__))

# Импортируем логирование из utils
from utils import setup_logging
logger = setup_logging('editor')

MODELS_DIR = os.path.join(BASE_DIR, "models")
os.makedirs(MODELS_DIR, exist_ok=True)


class CanvasItem:
    def __init__(self, layer, image_path):
        self.layer = layer
        self.image_path = image_path

        # Уникальный ID для надежного отслеживания в истории Undo/Redo
        self.uuid = layer.get('uuid', str(uuid.uuid4()))
        layer['uuid'] = self.uuid

        self.is_gif = bool(layer.get("is_gif", False))
        self.scale = float(layer.get("scale", 1.0))
        self.rotation = int(layer.get("rotation", 0))
        self.x = int(layer.get("x", 0))
        self.y = int(layer.get("y", 0))
        self.flip_horizontal = bool(layer.get("flip_horizontal", False))
        self.flip_vertical = bool(layer.get("flip_vertical", False))
        self.visible = bool(layer.get("visible", True))
        self.alpha = float(layer.get("alpha", 1.0))  # Прозрачность

        # Кэширование изображений для разных уровней зума
        self._zoom_cache = {}
        self._max_zoom_cache = 3
        self._preview_size = (1024, 1024)

        # Атрибуты для GIF
        self.gif_frames = []
        self.current_frame = 0
        self.last_frame_time = 0
        self.frame_durations = []

        # Загружаем оригинальное изображение (уменьшенное для производительности)
        self._original_image = None
        self._load_original_image()

    def _load_original_image(self):
        """Загружает и подготавливает изображение для отрисовки"""
        try:
            if self.is_gif:
                with Image.open(self.image_path) as gif:
                    gif.seek(0)
                    img = gif.copy().convert("RGBA")
                    # Уменьшаем только если изображение очень большое
                    if img.width > 1024 or img.height > 1024:
                        img.thumbnail((1024, 1024), Image.LANCZOS)
                    self._original_image = img

                    # Загружаем кадры GIF для анимации
                    self._load_gif_frames()
            else:
                img = Image.open(self.image_path).convert("RGBA")
                if img.width > 1024 or img.height > 1024:
                    img.thumbnail((1024, 1024), Image.LANCZOS)
                self._original_image = img
        except Exception as e:
            logger.error(f"Ошибка загрузки изображения: {e}")
            self._original_image = Image.new(
                "RGBA", (100, 100), (255, 0, 0, 128))

    def _load_gif_frames(self):
        """Загружает все кадры GIF"""
        try:
            if self.is_gif:
                with Image.open(self.image_path) as gif:
                    self.gif_frames = []
                    self.frame_durations = []
                    for frame in range(gif.n_frames):
                        gif.seek(frame)
                        frame_img = gif.copy().convert("RGBA")
                        if frame_img.width > 1024 or frame_img.height > 1024:
                            frame_img.thumbnail((1024, 1024), Image.LANCZOS)
                        self.gif_frames.append(frame_img)
                        try:
                            duration = gif.info.get('duration', 100)
                            if duration == 0:
                                duration = 100  # Защита от нулевой длительности
                            self.frame_durations.append(
                                duration / 1000.0)  # Конвертируем в секунды
                        except:
                            self.frame_durations.append(0.1)

                    # Инициализируем таймер
                    self.current_frame = 0
                    self.last_frame_time = time.time()
        except Exception as e:
            logger.error(f"Ошибка загрузки кадров GIF: {e}")
            self.is_gif = False

    def get_current_image(self):
        """Возвращает текущий кадр (для GIF) или изображение"""
        if self.is_gif and self.gif_frames:
            now = time.time()
            if now - self.last_frame_time > self.frame_durations[self.current_frame]:
                self.current_frame = (
                    self.current_frame + 1) % len(self.gif_frames)
                self.last_frame_time = now
            return self.gif_frames[self.current_frame]
        return self._original_image

    @lru_cache(maxsize=10)
    def _get_transformed_image_cached(self, zoom_level, scale, rotation, flip_h, flip_v, frame_idx=0, alpha=1.0):
        """Кэшированное получение трансформированного изображения"""
        # Получаем текущее изображение
        if self.is_gif and self.gif_frames:
            img = self.gif_frames[frame_idx % len(self.gif_frames)].copy()
        elif self._original_image:
            img = self._original_image.copy()
        else:
            return Image.new("RGBA", (10, 10), (255, 0, 0, 128))

        # ПРАВИЛЬНЫЙ ПОРЯДОК ТРАНСФОРМАЦИЙ:
        # 1. Масштаб элемента
        if scale != 1.0:
            new_width = max(1, int(img.width * scale))
            new_height = max(1, int(img.height * scale))
            img = img.resize((new_width, new_height), Image.LANCZOS)

        # 2. Отражение
        if flip_h:
            img = img.transpose(Image.FLIP_LEFT_RIGHT)
        if flip_v:
            img = img.transpose(Image.FLIP_TOP_BOTTOM)

        # 3. Поворот
        if rotation != 0:
            img = img.rotate(rotation, expand=True, resample=Image.BICUBIC)

        # 4. Применяем прозрачность (если не 1.0)
        if alpha < 1.0:
            if img.mode == 'RGBA':
                r, g, b, a = img.split()
                a = a.point(lambda x: int(x * alpha))
                img = Image.merge('RGBA', (r, g, b, a))

        # 5. Зум для отображения (только для редактора)
        if zoom_level != 1.0:
            final_width = max(1, int(img.width * zoom_level))
            final_height = max(1, int(img.height * zoom_level))
            img = img.resize((final_width, final_height), Image.LANCZOS)

        return img

    def _get_transformed_image(self, zoom_level=1.0):
        """Получает трансформированное изображение для заданного уровня зума"""
        logger.debug(f"Getting transformed image: scale={self.scale}, rotation={self.rotation}, "
                     f"flip_h={self.flip_horizontal}, flip_v={self.flip_vertical}, zoom={zoom_level}, alpha={self.alpha}")

        # Для GIF сначала обновляем текущий кадр
        if self.is_gif and self.gif_frames:
            self._update_gif_frame()

        # Проверяем кэш
        cache_key = f"{zoom_level:.2f}_{self.scale}_{self.rotation}_{self.flip_horizontal}_{self.flip_vertical}_{self.alpha}"

        if self.is_gif:
            # Для GIF добавляем номер кадра в ключ кэша
            cache_key += f"_{self.current_frame}"

        if cache_key in self._zoom_cache:
            return self._zoom_cache[cache_key]

        if not self._original_image and not self.gif_frames:
            return Image.new("RGBA", (10, 10), (255, 0, 0, 128))

        # Очищаем старый кэш если слишком много записей
        if len(self._zoom_cache) > self._max_zoom_cache:
            self._zoom_cache.clear()

        # Получаем текущее изображение
        if self.is_gif and self.gif_frames:
            # Для GIF используем текущий кадр
            img = self.gif_frames[self.current_frame].copy()
        else:
            img = self._original_image.copy()

        # ПРАВИЛЬНЫЙ ПОРЯДОК ТРАНСФОРМАЦИЙ:
        # 1. Масштаб элемента
        if self.scale != 1.0:
            new_width = max(1, int(img.width * self.scale))
            new_height = max(1, int(img.height * self.scale))
            img = img.resize((new_width, new_height), Image.LANCZOS)

        # 2. Отражение
        if self.flip_horizontal:
            img = img.transpose(Image.FLIP_LEFT_RIGHT)
        if self.flip_vertical:
            img = img.transpose(Image.FLIP_TOP_BOTTOM)

        # 3. Поворот
        if self.rotation != 0:
            img = img.rotate(self.rotation, expand=True,
                             resample=Image.BICUBIC)

        # 4. Применяем прозрачность (если не 1.0)
        if self.alpha < 1.0:
            if img.mode == 'RGBA':
                r, g, b, a = img.split()
                a = a.point(lambda x: int(x * self.alpha))
                img = Image.merge('RGBA', (r, g, b, a))

        # 5. Зум для отображения (только для редактора)
        if zoom_level != 1.0:
            final_width = max(1, int(img.width * zoom_level))
            final_height = max(1, int(img.height * zoom_level))
            img = img.resize((final_width, final_height), Image.LANCZOS)

        # Сохраняем в кэш
        self._zoom_cache[cache_key] = img
        return img

    def _update_gif_frame(self):
        """Обновляет текущий кадр GIF на основе времени"""
        if not self.is_gif or not self.gif_frames:
            return

        now = time.time()
        if now - self.last_frame_time >= self.frame_durations[self.current_frame]:
            self.current_frame = (self.current_frame +
                                  1) % len(self.gif_frames)
            self.last_frame_time = now

    def get_image_for_display(self, zoom_level=1.0):
        """Возвращает изображение для отображения с учетом зума"""
        if not self.visible:
            return None
        return self._get_transformed_image(zoom_level)

    def clear_cache(self):
        """Очищает кэш изображений"""
        self._get_transformed_image_cached.cache_clear()
        self._zoom_cache.clear()

        # Также очищаем Tkinter PhotoImage кэш
        if hasattr(self, '_tk_images'):
            self._tk_images.clear()


class ModelEditor(tk.Toplevel):
    def __init__(self, master, on_save=None, device='По умолчанию', noise_gate_threshold=0.01, sensitivity=1.0, current_slot=None, renderer=None):
        super().__init__(master)
        self.title(tr('editor_title'))
        self.geometry("1400x800")
        self.on_save = on_save
        self.protocol("WM_DELETE_WINDOW", self.on_close)
        self.current_slot = current_slot
        self.renderer = renderer  # Сохраняем ссылку на рендерер для синхронизации
        logger.info(f"Model editor opened, current slot: {current_slot}")

        # Регистрируем callback для обновления UI при смене языка
        i18n.register_callback(self.refresh_ui_texts)

        # Сохраняем настройки микрофона
        self.mic_device = device
        self.mic_noise_gate_threshold = noise_gate_threshold
        self.mic_sensitivity = sensitivity

        # Данные модели
        self.model = {"name": tr('default_model_name'), "layers": [],
                      "groups": [], "width": 700, "height": 700}
        # Состояния рта (макс 10)
        self.mouth_states = [
            {'id': 0, 'name': tr('default_state_0'),
             'threshold': 0.0, 'active': True},
            {'id': 1, 'name': tr('default_state_1'),
             'threshold': 0.3, 'active': True},
            {'id': 2, 'name': tr('default_state_2'),
             'threshold': 0.6, 'active': True},
            {'id': 3, 'name': tr('default_state_3'),
             'threshold': 0.9, 'active': True}
        ]

        self.model_dir = None
        self.original_slot = None
        self.items = []
        self.imported_files = []
        # Добавлены start_x и start_y для корректного определения движения мыши
        self.drag_data = {"item": None, "x": 0, "y": 0,
                          "start_x": 0, "start_y": 0, "group_items": []}
        self.selected_group = None
        self.current_selection = []
        self.preview_fps = 30
        self.last_autosave = time.time()
        self.autosave_interval = 5.0
        self.audio_level = 0.0
        self.blink_preview_running = False

        # ОПТИМИЗАЦИИ
        self._redraw_scheduled = False
        self._redraw_delay = 33  # ~30 FPS для редактора
        self._canvas_cache_valid = False
        self._last_redraw_time = 0
        self._photo_images = {}  # Кэш PhotoImage
        self._photo_cache_limit = 20

        # Кэширование изображений для дерева
        self._tree_image_cache = {}

        # Оптимизация событий мыши
        self._last_mouse_event = 0
        self._mouse_event_throttle = 0.016  # ~60 FPS для событий мыши

        # Система отмены/повтора
        self.history = []
        self.history_index = -1
        self.max_history_size = 50

        # Настройки холста
        self.canvas_width = 700
        self.canvas_height = 700

        # Настройки зума и просмотра
        self.zoom_level = 1.0
        self.zoom_step = 0.1
        self.min_zoom = 0.1
        self.max_zoom = 3.0  # Уменьшаем максимальный зум
        self.offset_x = 0
        self.offset_y = 0
        self.is_panning = False
        self.last_pan_x = 0
        self.last_pan_y = 0

        # Таймеры для анимаций
        self.group_blink_timers = {}
        self.group_blink_until = {}
        self.group_random_timers = {}
        self.group_random_current = {}

        # Состояние дерева для сохранения
        self.tree_state = {
            "expanded_groups": set(),
            "selected_items": set(),
            "preserve_selection": False
        }

        # Очищаем старые временные папки при запуске
        self.cleanup_old_temp_folders()

        # Создаем UI
        self._create_ui()

        # Сохраняем начальное состояние в историю
        self.save_to_history()

        # Запуск превью
        self.after(100, self._preview_loop)

    def _create_ui(self):
        """Создание пользовательского интерфейса"""
        main_frame = ttk.Frame(self)
        main_frame.pack(fill=tk.BOTH, expand=True, padx=6, pady=6)
        main_frame.columnconfigure(1, weight=1)
        main_frame.rowconfigure(0, weight=1)

        # Левая панель
        left_width = 300
        left = ttk.Frame(main_frame, width=left_width)
        left.grid(row=0, column=0, sticky="ns", padx=(0, 6), pady=0)
        left.grid_propagate(False)

        # Центральная панель
        center = ttk.Frame(main_frame)
        center.grid(row=0, column=1, sticky="nsew", padx=0, pady=0)

        # Правая панель
        right = ttk.Frame(main_frame, width=350)
        right.grid(row=0, column=2, sticky="ns", padx=(6, 0), pady=0)

        # ---- Левая панель ----
        # Имя модели
        name_frame = ttk.LabelFrame(left, text=tr('editor_model_name'))
        name_frame.pack(fill="x", pady=2)
        self._register_widget_i18n(name_frame, 'editor_model_name')

        self.model_name_var = tk.StringVar(value=tr('default_model_name'))
        name_entry = ttk.Entry(name_frame, textvariable=self.model_name_var)
        name_entry.pack(fill="x", padx=5, pady=5)
        name_entry.bind("<Return>", self.update_model_name)

        # Панель с кнопками управления моделью
        button_row1 = ttk.Frame(left)
        button_row1.pack(fill="x", pady=2)
        new_btn = ttk.Button(button_row1, text=tr(
            'editor_new'), command=self.new_model, width=10)
        new_btn.pack(side="left", padx=1, fill="x", expand=True)
        self._register_widget_i18n(new_btn, 'editor_new')

        load_btn = ttk.Button(button_row1, text=tr(
            'editor_load'), command=self.load_model, width=10)
        load_btn.pack(side="left", padx=1, fill="x", expand=True)
        self._register_widget_i18n(load_btn, 'editor_load')

        save_btn = ttk.Button(button_row1, text=tr(
            'editor_save'), command=self.save_model, width=10)
        save_btn.pack(side="left", padx=1, fill="x", expand=True)
        self._register_widget_i18n(save_btn, 'editor_save')

        button_row2 = ttk.Frame(left)
        button_row2.pack(fill="x", pady=2)
        import_btn = ttk.Button(button_row2, text=tr(
            'editor_import'), command=self.import_images, width=15)
        import_btn.pack(side="left", padx=1, fill="x", expand=True)
        self._register_widget_i18n(import_btn, 'editor_import')

        button_row3 = ttk.Frame(left)
        button_row3.pack(fill="x", pady=2)
        export_zip_btn = ttk.Button(button_row3, text=tr(
            'editor_export_zip'), command=self.export_zip, width=10)
        export_zip_btn.pack(side="left", padx=1, fill="x", expand=True)
        self._register_widget_i18n(export_zip_btn, 'editor_export_zip')

        import_zip_btn = ttk.Button(button_row3, text=tr(
            'editor_import_zip'), command=self.import_zip, width=10)
        import_zip_btn.pack(side="left", padx=1, fill="x", expand=True)
        self._register_widget_i18n(import_zip_btn, 'editor_import_zip')

        # Кнопка удаления модели
        delete_model_btn = ttk.Button(left, text=tr(
            'editor_delete_model'), command=self.delete_model)
        delete_model_btn.pack(fill="x", pady=2)
        self._register_widget_i18n(delete_model_btn, 'editor_delete_model')

        # Настройки холста
        canvas_frame = ttk.LabelFrame(left, text=tr('editor_canvas_settings'))
        canvas_frame.pack(fill="x", pady=10)
        self._register_widget_i18n(canvas_frame, 'editor_canvas_settings')

        ttk.Label(canvas_frame, text=tr('editor_width')).grid(
            row=0, column=0, sticky="w", padx=2, pady=2)
        self.canvas_width_var = tk.IntVar(value=self.canvas_width)
        width_entry = ttk.Entry(
            canvas_frame, textvariable=self.canvas_width_var, width=8)
        width_entry.grid(row=0, column=1, sticky="ew", padx=2, pady=2)
        width_entry.bind("<Return>", self.update_canvas_size)

        ttk.Label(canvas_frame, text=tr('editor_height')).grid(
            row=1, column=0, sticky="w", padx=2, pady=2)
        self.canvas_height_var = tk.IntVar(value=self.canvas_height)
        height_entry = ttk.Entry(
            canvas_frame, textvariable=self.canvas_height_var, width=8)
        height_entry.grid(row=1, column=1, sticky="ew", padx=2, pady=2)
        height_entry.bind("<Return>", self.update_canvas_size)

        apply_canvas_btn = ttk.Button(canvas_frame, text=tr(
            'editor_apply'), command=self.update_canvas_size)
        apply_canvas_btn.grid(row=2, column=0, columnspan=2, pady=5)
        self._register_widget_i18n(apply_canvas_btn, 'editor_apply')

        # Управление зумом
        zoom_frame = ttk.Frame(canvas_frame)
        zoom_frame.grid(row=3, column=0, columnspan=2, sticky="ew", pady=5)
        zoom_in_btn = ttk.Button(zoom_frame, text=tr(
            'editor_zoom_in'), width=3, command=self.zoom_in)
        zoom_in_btn.pack(side="left", padx=2)
        self._register_widget_i18n(zoom_in_btn, 'editor_zoom_in')
        zoom_out_btn = ttk.Button(zoom_frame, text=tr(
            'editor_zoom_out'), width=3, command=self.zoom_out)
        zoom_out_btn.pack(side="left", padx=2)
        self._register_widget_i18n(zoom_out_btn, 'editor_zoom_out')
        zoom_reset_btn = ttk.Button(zoom_frame, text=tr(
            'editor_zoom_reset'), width=6, command=self.zoom_reset)
        zoom_reset_btn.pack(side="left", padx=2)
        self._register_widget_i18n(zoom_reset_btn, 'editor_zoom_reset')

        # Режим тестирования
        test_frame = ttk.LabelFrame(left, text=tr('editor_test_mode'))
        test_frame.pack(fill="x", pady=10)
        self._register_widget_i18n(test_frame, 'editor_test_mode')

        self.test_mode_var = tk.StringVar(value="none")
        mic_radio = ttk.Radiobutton(test_frame, text=tr('editor_microphone'), variable=self.test_mode_var,
                                    value="microphone", command=self.update_test_mode)
        mic_radio.pack(anchor="w")
        self._register_widget_i18n(mic_radio, 'editor_microphone')
        off_radio = ttk.Radiobutton(test_frame, text=tr('editor_off'), variable=self.test_mode_var,
                                    value="none", command=self.update_test_mode)
        off_radio.pack(anchor="w")
        self._register_widget_i18n(off_radio, 'editor_off')

        # Индикатор уровня
        self.level_frame = ttk.Frame(test_frame)
        self.level_frame.pack(fill="x", pady=5)
        level_label = ttk.Label(self.level_frame, text=tr('editor_level'))
        level_label.pack(side="left")
        self._register_widget_i18n(level_label, 'editor_level')
        self.level_bar = ttk.Progressbar(
            self.level_frame, length=200, mode="determinate")
        self.level_bar.pack(side="left", fill="x", expand=True, padx=5)

        # Аудиопроцессор
        self.audio_processor = AudioProcessor(
            callback=self.on_audio_level,
            device=self.mic_device
        )
        self.audio_processor.noise_gate_threshold = self.mic_noise_gate_threshold
        self.audio_processor.set_sensitivity(self.mic_sensitivity)

        imported_label = ttk.Label(left, text=tr('editor_imported'))
        imported_label.pack(anchor="w", pady=(8, 0))
        self._register_widget_i18n(imported_label, 'editor_imported')

        # Список импортированных изображений
        import_frame = ttk.Frame(left)
        import_frame.pack(fill="both", expand=True)
        self.import_canvas = tk.Canvas(import_frame, width=280, height=250)
        self.import_vscroll = ttk.Scrollbar(
            import_frame, orient="vertical", command=self.import_canvas.yview)
        self.import_canvas.configure(yscrollcommand=self.import_vscroll.set)
        self.import_vscroll.pack(side="right", fill="y")
        self.import_canvas.pack(side="left", fill="both", expand=True)

        self.import_inner = ttk.Frame(self.import_canvas)
        self.import_canvas.create_window(
            (0, 0), window=self.import_inner, anchor="nw")
        self.import_inner.bind("<Configure>", lambda e: self.import_canvas.configure(
            scrollregion=self.import_canvas.bbox("all")))

        # ---- Центральная панель ----
        # Заголовок предпросмотра с кнопками отмены/повтора
        preview_header = ttk.Frame(center)
        preview_header.pack(fill="x", padx=5, pady=(0, 5))

        preview_label = ttk.Label(preview_header, text=tr(
            'editor_preview'), font=("Arial", 10, "bold"))
        preview_label.pack(side="left", padx=(0, 10))
        self._register_widget_i18n(preview_label, 'editor_preview')

        # Кнопки отмены/повтора
        undo_btn = ttk.Button(preview_header, text=tr(
            'editor_undo'), width=2, command=self.undo)
        undo_btn.pack(side="left", padx=2)
        self._register_widget_i18n(undo_btn, 'editor_undo')
        redo_btn = ttk.Button(preview_header, text=tr(
            'editor_redo'), width=2, command=self.redo)
        redo_btn.pack(side="left", padx=2)
        self._register_widget_i18n(redo_btn, 'editor_redo')

        preview_frame = ttk.Frame(center)
        preview_frame.pack(fill="both", expand=True)

        # Создаем основной canvas для отображения
        self.canvas = tk.Canvas(preview_frame, bg="#222", cursor="crosshair")
        self.canvas.pack(fill="both", expand=True, padx=5, pady=5)

        # Привязка событий
        self.canvas.bind("<ButtonPress-1>", self.on_canvas_mouse_down)
        self.canvas.bind("<B1-Motion>", self.on_canvas_mouse_move)
        self.canvas.bind("<ButtonRelease-1>", self.on_canvas_mouse_up)
        self.canvas.bind("<MouseWheel>", self.on_canvas_zoom)
        self.canvas.bind("<Button-4>", self.on_canvas_zoom)
        self.canvas.bind("<Button-5>", self.on_canvas_zoom)
        self.canvas.bind("<ButtonPress-2>", self.on_canvas_pan_start)
        self.canvas.bind("<B2-Motion>", self.on_canvas_pan_move)
        self.bind("<Configure>", self.on_window_resize)

        # Привязка горячих клавиш для отмены/повтора
        self.bind_all("<Control-z>", self.undo)
        self.bind_all("<Control-y>", self.redo)

        # ---- Правая панель ----
        notebook = ttk.Notebook(right)
        notebook.pack(fill="both", expand=True)

        # Вкладка 1: Управление элементами
        items_tab = ttk.Frame(notebook)
        notebook.add(items_tab, text=tr('editor_items'))

        # Вкладка 2: Логика групп
        groups_tab = ttk.Frame(notebook)
        notebook.add(groups_tab, text=tr('editor_groups'))

        # Вкладка 3: Состояния рта (НОВАЯ)
        mouth_states_tab = ttk.Frame(notebook)
        notebook.add(mouth_states_tab, text=tr('editor_mouth_states'))

        # ---- Вкладка "Элементы" ----
        items_frame = ttk.LabelFrame(items_tab, text=tr('editor_canvas_items'))
        items_frame.pack(fill="both", expand=True, padx=5, pady=5)
        self._register_widget_i18n(items_frame, 'editor_canvas_items')

        # Древовидный список элементов
        items_list_frame = ttk.Frame(items_frame)
        items_list_frame.pack(fill="both", expand=True, pady=(0, 5))

        # Создаем Treeview с вертикальной прокруткой и множественным выбором
        self.tree = ttk.Treeview(
            items_list_frame, show="tree", height=15, selectmode='extended')
        scrollbar = ttk.Scrollbar(
            items_list_frame, orient="vertical", command=self.tree.yview)
        self.tree.configure(yscrollcommand=scrollbar.set)
        scrollbar.pack(side="right", fill="y")
        self.tree.pack(side="left", fill="both", expand=True)
        self.tree.bind("<<TreeviewSelect>>", self.on_tree_select)

        # Кнопки управления
        btns_frame = ttk.Frame(items_frame)
        btns_frame.pack(fill="x", pady=(0, 10))
        bring_btn = ttk.Button(btns_frame, text=tr(
            'editor_bring_forward'), width=3, command=self.bring_forward)
        bring_btn.pack(side="left", padx=2)
        self._register_widget_i18n(bring_btn, 'editor_bring_forward')
        send_btn = ttk.Button(btns_frame, text=tr(
            'editor_send_backward'), width=3, command=self.send_backward)
        send_btn.pack(side="left", padx=2)
        self._register_widget_i18n(send_btn, 'editor_send_backward')
        group_btn = ttk.Button(btns_frame, text=tr(
            'editor_group'), command=self.group_selected)
        group_btn.pack(side="left", padx=2, fill="x", expand=True)
        self._register_widget_i18n(group_btn, 'editor_group')
        ungroup_btn = ttk.Button(btns_frame, text=tr(
            'editor_ungroup'), command=self.ungroup_selected)
        ungroup_btn.pack(side="left", padx=2, fill="x", expand=True)
        self._register_widget_i18n(ungroup_btn, 'editor_ungroup')

        # Свойства элемента
        props = ttk.LabelFrame(items_frame, text=tr('editor_item_props'))
        props.pack(fill="x", pady=(0, 5))
        self._register_widget_i18n(props, 'editor_item_props')

        grid_frame = ttk.Frame(props)
        grid_frame.pack(fill="x", padx=5, pady=5)

        ttk.Label(grid_frame, text=tr('editor_name')).grid(
            row=0, column=0, sticky="w", padx=2, pady=2)
        self.name_entry = ttk.Entry(grid_frame)
        self.name_entry.grid(row=0, column=1, sticky="ew", padx=2, pady=2)
        self.name_entry.bind("<FocusIn>", lambda e: "break")

        ttk.Label(grid_frame, text=tr('editor_x')).grid(
            row=1, column=0, sticky="w", padx=2, pady=2)
        self.x_entry = ttk.Entry(grid_frame)
        self.x_entry.grid(row=1, column=1, sticky="ew", padx=2, pady=2)
        self.x_entry.bind("<Return>", self.apply_props_from_entry)
        self.x_entry.bind("<FocusIn>", lambda e: "break")

        ttk.Label(grid_frame, text=tr('editor_y')).grid(
            row=2, column=0, sticky="w", padx=2, pady=2)
        self.y_entry = ttk.Entry(grid_frame)
        self.y_entry.grid(row=2, column=1, sticky="ew", padx=2, pady=2)
        self.y_entry.bind("<Return>", self.apply_props_from_entry)
        self.y_entry.bind("<FocusIn>", lambda e: "break")

        ttk.Label(grid_frame, text=tr('editor_scale')).grid(
            row=3, column=0, sticky="w", padx=2, pady=2)
        self.scale_entry = ttk.Entry(grid_frame)
        self.scale_entry.grid(row=3, column=1, sticky="ew", padx=2, pady=2)
        self.scale_entry.bind("<Return>", self.apply_props_from_entry)
        self.scale_entry.bind("<FocusIn>", lambda e: "break")

        ttk.Label(grid_frame, text=tr('editor_rotation')).grid(
            row=4, column=0, sticky="w", padx=2, pady=2)
        self.rotation_entry = ttk.Entry(grid_frame)
        self.rotation_entry.grid(row=4, column=1, sticky="ew", padx=2, pady=2)
        self.rotation_entry.bind("<Return>", self.apply_props_from_entry)
        self.rotation_entry.bind("<FocusIn>", lambda e: "break")

        ttk.Label(grid_frame, text=tr('editor_alpha')).grid(
            row=5, column=0, sticky="w", padx=2, pady=2)
        self.alpha_entry = ttk.Entry(grid_frame)
        self.alpha_entry.grid(row=5, column=1, sticky="ew", padx=2, pady=2)
        self.alpha_entry.bind("<Return>", self.apply_props_from_entry)
        self.alpha_entry.bind("<FocusIn>", lambda e: "break")

        # Зеркалирование
        mirror_frame = ttk.Frame(props)
        mirror_frame.pack(fill="x", padx=5, pady=2)
        mirror_label = ttk.Label(mirror_frame, text=tr('editor_mirror'))
        mirror_label.pack(side="left")
        self._register_widget_i18n(mirror_label, 'editor_mirror')
        self.flip_h_var = tk.BooleanVar(value=False)
        self.flip_v_var = tk.BooleanVar(value=False)
        self.flip_h_cb = ttk.Checkbutton(mirror_frame, text=tr('editor_mirror_h'), variable=self.flip_h_var,
                                         command=self.on_mirror_change)
        self.flip_h_cb.pack(side="left", padx=5)
        self._register_widget_i18n(self.flip_h_cb, 'editor_mirror_h')
        self.flip_v_cb = ttk.Checkbutton(mirror_frame, text=tr('editor_mirror_v'), variable=self.flip_v_var,
                                         command=self.on_mirror_change)
        self.flip_v_cb.pack(side="left", padx=5)
        self._register_widget_i18n(self.flip_v_cb, 'editor_mirror_v')

        # ВИДИМОСТЬ
        self.visible_var = tk.BooleanVar(value=True)
        self.visible_cb = ttk.Checkbutton(props, text=tr('editor_visible'), variable=self.visible_var,
                                          command=self.on_visible_change)
        self.visible_cb.pack(anchor="w", padx=5, pady=(0, 5))
        self._register_widget_i18n(self.visible_cb, 'editor_visible')

        apply_props_btn = ttk.Button(props, text=tr(
            'editor_apply_props'), command=self.apply_props)
        apply_props_btn.pack(fill="x", padx=5, pady=5)
        self._register_widget_i18n(apply_props_btn, 'editor_apply_props')

        delete_selected_btn = ttk.Button(props, text=tr(
            'editor_delete_selected'), command=self.delete_selected_items)
        delete_selected_btn.pack(fill="x", padx=5, pady=5)
        self._register_widget_i18n(
            delete_selected_btn, 'editor_delete_selected')

        # ---- Вкладка "Логика групп" ----
        groups_frame = ttk.LabelFrame(
            groups_tab, text=tr('editor_group_logic'))
        groups_frame.pack(fill="both", expand=True, padx=5, pady=5)
        self._register_widget_i18n(groups_frame, 'editor_group_logic')

        # Выбранная группа
        group_info_frame = ttk.Frame(groups_frame)
        group_info_frame.pack(fill="x", pady=(0, 10))
        group_info_label = ttk.Label(
            group_info_frame, text=tr('editor_selected_group'))
        group_info_label.pack(side="left", padx=(0, 5))
        self._register_widget_i18n(group_info_label, 'editor_selected_group')
        self.group_label = ttk.Label(
            group_info_frame, text=tr('editor_no_group'), font=("Arial", 9, "bold"))
        self.group_label.pack(side="left")

        # Настройки логики
        logic_frame = ttk.LabelFrame(
            groups_frame, text=tr('editor_state_to_layer'))
        logic_frame.pack(fill="x", pady=(0, 10))
        self._register_widget_i18n(logic_frame, 'editor_state_to_layer')

        # Словарь для переменных состояний будет заполнен динамически
        self.state_vars = {}

        # Место для динамических меню
        self.logic_content_frame = ttk.Frame(logic_frame)
        self.logic_content_frame.pack(fill="x", padx=5, pady=5)

        # Случайный эффект
        random_frame = ttk.LabelFrame(
            groups_tab, text=tr('editor_random_effect'))
        random_frame.pack(fill="x", pady=(0, 10))
        self._register_widget_i18n(random_frame, 'editor_random_effect')

        self.random_effect_var = tk.BooleanVar(value=False)
        random_cb = ttk.Checkbutton(random_frame, text=tr('editor_random_effect'),
                                    variable=self.random_effect_var)
        random_cb.pack(anchor="w", padx=5, pady=2)
        self._register_widget_i18n(random_cb, 'editor_random_effect')

        interval_frame = ttk.Frame(random_frame)
        interval_frame.pack(fill="x", padx=5, pady=2)
        interval_label = ttk.Label(
            interval_frame, text=tr('editor_random_interval'))
        interval_label.pack(side="left")
        self._register_widget_i18n(interval_label, 'editor_random_interval')
        self.random_min_var = tk.DoubleVar(value=5.0)
        ttk.Entry(interval_frame, textvariable=self.random_min_var,
                  width=5).pack(side="left", padx=2)
        to_label = ttk.Label(interval_frame, text=tr('editor_random_to'))
        to_label.pack(side="left")
        self._register_widget_i18n(to_label, 'editor_random_to')
        self.random_max_var = tk.DoubleVar(value=10.0)
        ttk.Entry(interval_frame, textvariable=self.random_max_var,
                  width=5).pack(side="left", padx=2)
        sec_label = ttk.Label(interval_frame, text=tr('editor_random_seconds'))
        sec_label.pack(side="left")
        self._register_widget_i18n(sec_label, 'editor_random_seconds')

        # Настройки моргания
        blink_frame = ttk.LabelFrame(
            groups_tab, text=tr('editor_blink_settings'))
        blink_frame.pack(fill="x", pady=(0, 10))
        self._register_widget_i18n(blink_frame, 'editor_blink_settings')

        freq_frame = ttk.Frame(blink_frame)
        freq_frame.pack(fill="x", padx=5, pady=2)
        freq_label = ttk.Label(freq_frame, text=tr('editor_blink_freq'))
        freq_label.pack(side="left")
        self._register_widget_i18n(freq_label, 'editor_blink_freq')
        self.blink_freq = tk.DoubleVar(value=0.0)
        self.blink_freq_entry = ttk.Entry(
            freq_frame, width=6, textvariable=self.blink_freq)
        self.blink_freq_entry.pack(side="left", padx=2)
        ttk.Label(freq_frame, text="сек (0=выкл)").pack(
            side="left", padx=(5, 0))

        btn_frame = ttk.Frame(blink_frame)
        btn_frame.pack(fill="x", padx=5, pady=(0, 5))
        preview_blink_btn = ttk.Button(btn_frame, text=tr('editor_blink_preview'), width=8,
                                       command=self.show_blink_preview)
        preview_blink_btn.pack(side="left", padx=2)
        self._register_widget_i18n(preview_blink_btn, 'editor_blink_preview')
        stop_blink_btn = ttk.Button(btn_frame, text=tr(
            'editor_blink_stop'), command=self.stop_blink_preview)
        stop_blink_btn.pack(side="left", padx=2)
        self._register_widget_i18n(stop_blink_btn, 'editor_blink_stop')

        # Кнопка применения
        apply_logic_btn = ttk.Button(groups_frame, text=tr(
            'editor_apply_logic'), command=self.apply_group_logic)
        apply_logic_btn.pack(fill="x", pady=10)
        self._register_widget_i18n(apply_logic_btn, 'editor_apply_logic')

        # ---- Вкладка "Состояния рта" (НОВАЯ) ----
        self._create_mouth_states_ui(mouth_states_tab)

        try:
            self.iconbitmap(os.path.join(BASE_DIR, 'favicon.ico'))
        except Exception as e:
            logger.error(f"Error loading icon: {e}")

    def _register_widget_i18n(self, widget, key, **kwargs):
        """Сохраняет ключ перевода для виджета."""
        widget._i18n_key = key
        widget._i18n_kwargs = kwargs

    def refresh_ui_texts(self):
        """Обновляет все тексты в интерфейсе редактора согласно текущему языку."""
        def update_widgets(widget):
            if hasattr(widget, '_i18n_key'):
                try:
                    kwargs = getattr(widget, '_i18n_kwargs', {})
                    new_text = tr(widget._i18n_key, **kwargs)
                    try:
                        widget.config(text=new_text)
                    except:
                        pass
                except:
                    pass
            try:
                for child in widget.winfo_children():
                    update_widgets(child)
            except:
                pass

        update_widgets(self)
        # Обновляем заголовок окна
        self.title(tr('editor_title'))
        # Обновляем имя модели (если оно не было изменено пользователем)
        if self.model_name_var.get() == tr('default_model_name'):
            self.model_name_var.set(tr('default_model_name'))
        # Обновляем состояния рта, если они стандартные
        # (можно перезагрузить модель, но лучше просто обновить UI списка)
        self.refresh_mouth_states_list()
        self.refresh_tree()  # обновить дерево (текст элементов)
        self.redraw_canvas()

    def _create_mouth_states_ui(self, parent):
        """Создаёт UI для управления состояниями рта"""
        main_frame = ttk.Frame(parent)
        main_frame.pack(fill="both", expand=True, padx=5, pady=5)

        # Заголовок
        title_label = ttk.Label(main_frame, text=tr(
            'editor_mouth_states_manage'), font=("Arial", 9, "bold"))
        title_label.pack(anchor="w", pady=(0, 5))
        self._register_widget_i18n(title_label, 'editor_mouth_states_manage')

        # Верхняя панель с кнопками
        btn_frame = ttk.Frame(main_frame)
        btn_frame.pack(fill="x", pady=(0, 5))

        add_state_btn = ttk.Button(btn_frame, text=tr(
            'editor_add_state'), width=12, command=self.add_mouth_state)
        add_state_btn.pack(side="left", padx=2)
        self._register_widget_i18n(add_state_btn, 'editor_add_state')

        delete_state_btn = ttk.Button(btn_frame, text=tr(
            'editor_delete_state'), width=8, command=self.delete_mouth_state)
        delete_state_btn.pack(side="left", padx=2)
        self._register_widget_i18n(delete_state_btn, 'editor_delete_state')

        # Панель со списком состояний
        list_frame = ttk.Frame(main_frame)
        list_frame.pack(fill="both", expand=True, pady=(0, 5))

        # Treeview для списка состояний
        columns = ('#1', '#2', '#3')
        self.states_tree = ttk.Treeview(
            list_frame, columns=columns, show='headings', height=8)
        self.states_tree.heading('#1', text=tr('editor_state_name'))
        self.states_tree.heading('#2', text=tr('editor_state_threshold'))
        self.states_tree.heading('#3', text=tr('editor_state_active'))
        self.states_tree.column('#1', width=120, anchor='w')
        self.states_tree.column('#2', width=60, anchor='center')
        self.states_tree.column('#3', width=60, anchor='center')

        scrollbar = ttk.Scrollbar(
            list_frame, orient="vertical", command=self.states_tree.yview)
        self.states_tree.configure(yscrollcommand=scrollbar.set)
        self.states_tree.pack(side="left", fill="both", expand=True)
        scrollbar.pack(side="right", fill="y")

        self.states_tree.bind('<<TreeviewSelect>>', self.on_mouth_state_select)

        # Панель свойств выбранного состояния
        props_frame = ttk.LabelFrame(main_frame, text=tr('editor_state_props'))
        props_frame.pack(fill="x", pady=(0, 5))
        self._register_widget_i18n(props_frame, 'editor_state_props')

        props_grid = ttk.Frame(props_frame)
        props_grid.pack(fill="x", padx=5, pady=5)

        # Название
        name_label = ttk.Label(props_grid, text=tr('editor_state_name'))
        name_label.grid(row=0, column=0, sticky="w", padx=2, pady=2)
        self._register_widget_i18n(name_label, 'editor_state_name')
        self.state_name_entry = ttk.Entry(props_grid, width=20)
        self.state_name_entry.grid(
            row=0, column=1, sticky="ew", padx=2, pady=2)

        # Порог
        threshold_label = ttk.Label(
            props_grid, text=tr('editor_state_threshold'))
        threshold_label.grid(row=1, column=0, sticky="w", padx=2, pady=2)
        self._register_widget_i18n(threshold_label, 'editor_state_threshold')
        self.state_threshold_var = tk.DoubleVar(value=0.0)
        self.state_threshold_entry = ttk.Entry(
            props_grid, textvariable=self.state_threshold_var, width=8)
        self.state_threshold_entry.grid(
            row=1, column=1, sticky="w", padx=2, pady=2)

        # Активно
        self.state_active_var = tk.BooleanVar(value=True)
        active_cb = ttk.Checkbutton(props_grid, text=tr(
            'editor_state_active'), variable=self.state_active_var)
        active_cb.grid(row=2, column=0, columnspan=2,
                       sticky="w", padx=2, pady=2)
        self._register_widget_i18n(active_cb, 'editor_state_active')

        # Кнопка "Применить"
        apply_state_btn = ttk.Button(props_grid, text=tr(
            'editor_state_apply'), command=self.apply_mouth_state_props)
        apply_state_btn.grid(
            row=3, column=0, columnspan=2, pady=5, sticky="ew")
        self._register_widget_i18n(apply_state_btn, 'editor_state_apply')

        # Кнопка "Авто-распределить пороги"
        auto_thresholds_btn = ttk.Button(main_frame, text=tr('editor_auto_thresholds'),
                                         command=self.auto_distribute_thresholds)
        auto_thresholds_btn.pack(fill="x", pady=5)
        self._register_widget_i18n(
            auto_thresholds_btn, 'editor_auto_thresholds')

        # Обновляем список состояний
        self.refresh_mouth_states_list()

    def refresh_mouth_states_list(self):
        """Обновляет список состояний рта в UI"""
        # Очищаем дерево
        for item in self.states_tree.get_children():
            self.states_tree.delete(item)

        # Добавляем состояния
        for i, state in enumerate(self.mouth_states):
            active_text = "✓" if state.get('active', True) else "✗"
            self.states_tree.insert('', 'end', iid=str(i), values=(
                state.get('name', f'Состояние {i+1}'),
                f"{state.get('threshold', 0.0):.2f}",
                active_text
            ))

        # Обновляем меню в логике групп
        self.refresh_mouth_state_menus()

    def refresh_mouth_state_menus(self):
        """Обновляет меню состояний в логике групп"""
        # Очищаем предыдущие меню
        for widget in self.logic_content_frame.winfo_children():
            widget.destroy()

        self.state_vars = {}

        # Создаем меню для каждого состояния
        for i, state in enumerate(self.mouth_states):
            state_key = f"state_{i}"
            state_name = state.get('name', f'Состояние {i+1}')
            self.state_vars[state_key] = tk.StringVar(value="")

            row = ttk.Frame(self.logic_content_frame)
            row.pack(fill="x", padx=2, pady=2)
            ttk.Label(row, text=f"{state_name}:", width=15).pack(side="left")

            # OptionMenu с выбором слоев/групп
            om = ttk.OptionMenu(row, self.state_vars[state_key], "")
            om.pack(side="left", fill="x", expand=True)
            setattr(self, f"{state_key}_menu", om)

        # Добавляем отдельные меню для blink и open
        row_blink = ttk.Frame(self.logic_content_frame)
        row_blink.pack(fill="x", padx=2, pady=2)
        ttk.Label(row_blink, text=tr('editor_blink_settings') + " (blink):",
                  width=15).pack(side="left")
        self.blink_var = tk.StringVar(value="")
        blink_om = ttk.OptionMenu(row_blink, self.blink_var, "")
        blink_om.pack(side="left", fill="x", expand=True)
        setattr(self, "blink_menu", blink_om)

        row_open = ttk.Frame(self.logic_content_frame)
        row_open.pack(fill="x", padx=2, pady=2)
        ttk.Label(row_open, text="Открыто (open):", width=15).pack(side="left")
        self.open_var = tk.StringVar(value="")
        open_om = ttk.OptionMenu(row_open, self.open_var, "")
        open_om.pack(side="left", fill="x", expand=True)
        setattr(self, "open_menu", open_om)

    def on_mouth_state_select(self, event):
        """Обработчик выбора состояния в списке"""
        selection = self.states_tree.selection()
        if not selection:
            return

        idx = int(selection[0])
        if 0 <= idx < len(self.mouth_states):
            state = self.mouth_states[idx]
            self.state_name_entry.delete(0, tk.END)
            self.state_name_entry.insert(0, state.get('name', ''))
            self.state_threshold_var.set(state.get('threshold', 0.0))
            self.state_active_var.set(state.get('active', True))

    def apply_mouth_state_props(self):
        """Применяет свойства к выбранному состоянию"""
        selection = self.states_tree.selection()
        if not selection:
            messagebox.showwarning(tr('warning'), tr('editor_no_group'))
            return

        idx = int(selection[0])
        if 0 <= idx < len(self.mouth_states):
            # Название
            new_name = self.state_name_entry.get().strip()
            if new_name:
                self.mouth_states[idx]['name'] = new_name

            # Порог
            try:
                threshold = self.state_threshold_var.get()
                threshold = max(0.0, min(1.0, threshold))
                self.mouth_states[idx]['threshold'] = threshold
            except:
                messagebox.showwarning(
                    tr('warning'), tr('editor_state_threshold'))
                return

            # Активность
            self.mouth_states[idx]['active'] = self.state_active_var.get()

            # Обновляем список
            self.refresh_mouth_states_list()

            logger.info(f"Mouth state {idx} updated")

    def add_mouth_state(self):
        """Добавляет новое состояние рта (макс. 10)"""
        if len(self.mouth_states) >= 10:
            messagebox.showwarning(tr('warning'), tr(
                'editor_mouth_states_manage'))
            return

        # Генерируем уникальное имя
        base_name = "Новое состояние"
        new_name = base_name
        counter = 1
        existing_names = [s['name'] for s in self.mouth_states]
        while new_name in existing_names:
            new_name = f"{base_name} {counter}"
            counter += 1

        # Создаем новое состояние с авто-распределением порога
        new_id = len(self.mouth_states)
        new_state = {
            'id': new_id,
            'name': new_name,
            'threshold': 0.5,  # Временное значение, будет перераспределено
            'active': True
        }
        self.mouth_states.append(new_state)

        # Автоматически распределяем пороги
        self.auto_distribute_thresholds()

        logger.info(f"Added new mouth state: {new_name}")

    def delete_mouth_state(self):
        """Удаляет выбранное состояние рта"""
        selection = self.states_tree.selection()
        if not selection:
            messagebox.showwarning(tr('warning'), tr('editor_no_group'))
            return

        if len(self.mouth_states) <= 1:
            messagebox.showwarning(
                tr('warning'), tr('editor_empty'))
            return

        idx = int(selection[0])
        confirm = messagebox.askyesno(
            tr('delete_confirm_title'), f"Удалить состояние '{self.mouth_states[idx]['name']}'?")
        if not confirm:
            return

        del self.mouth_states[idx]

        # Переиндексируем id
        for i, state in enumerate(self.mouth_states):
            state['id'] = i

        # Перераспределяем пороги
        self.auto_distribute_thresholds()

        # Сбрасываем выделение в списке
        self.state_name_entry.delete(0, tk.END)
        self.state_threshold_var.set(0.0)
        self.state_active_var.set(True)

        logger.info(f"Deleted mouth state {idx}")

    def auto_distribute_thresholds(self):
        """Автоматически распределяет пороги между состояниями"""
        n = len(self.mouth_states)
        if n <= 1:
            if n == 1:
                self.mouth_states[0]['threshold'] = 0.0
        else:
            step = 1.0 / (n - 1)
            for i, state in enumerate(self.mouth_states):
                state['threshold'] = round(i * step, 2)

        self.refresh_mouth_states_list()
        logger.info(f"Auto-distributed thresholds for {n} states")

    def _get_groups_recursive(self, parent_name=None):
        """Получает все группы рекурсивно, начиная с указанной родительской группы"""
        if parent_name is None:
            # Получаем корневые группы (без родителя)
            return [g for g in self.model.get("groups", []) if not g.get("parent")]

        # Получаем дочерние группы для указанной родительской группы
        return [g for g in self.model.get("groups", []) if g.get("parent") == parent_name]

    def _get_all_items_in_group_recursive(self, group_name):
        """Рекурсивно получает все элементы группы и её дочерних групп"""
        items = []
        # Непосредственные элементы группы
        for ci in self.items:
            if ci.layer.get("group") == group_name:
                items.append(ci)
        # Рекурсивно для дочерних групп
        for g in self.model.get("groups", []):
            if g.get("parent") == group_name:
                items.extend(
                    self._get_all_items_in_group_recursive(g.get("name")))
        return items

    def _get_current_state_for_group(self, group_name):
        """Определяет текущее состояние для группы с учетом иерархии"""
        group = next((g for g in self.model.get("groups", [])
                      if g.get("name") == group_name), None)
        if not group:
            return None

        logic = group.get("logic", {})
        now = time.time()

        # Обработка моргания
        if self.test_mode_var.get() != "none":
            blink_freq = float(group.get("blink_freq", 0.0))
            if group_name not in self.group_blink_timers:
                self.group_blink_timers[group_name] = now + \
                    random.uniform(2.0, 6.0)
                self.group_blink_until[group_name] = 0.0

            if blink_freq > 0.001:
                if now > self.group_blink_timers.get(group_name, 0):
                    self.group_blink_until[group_name] = now + 0.12
                    self.group_blink_timers[group_name] = now + blink_freq

                if now < self.group_blink_until.get(group_name, 0):
                    if "blink" in logic and logic["blink"]:
                        return logic["blink"]
                    else:
                        # Автоматический поиск слоя для моргания
                        for layer in self.model.get("layers", []):
                            if layer.get("group") == group_name:
                                name = layer.get("name", "").lower()
                                if any(kw in name for kw in ["close", "closed", "shut", "blink", "морг", "закр"]):
                                    return layer.get("name")

        # Обработка случайного эффекта
        if group.get("random_effect", False):
            min_time = group.get("random_min", 5.0)
            max_time = group.get("random_max", 10.0)

            if group_name not in self.group_random_timers:
                self.group_random_timers[group_name] = now
                self.group_random_current[group_name] = None

            if now > self.group_random_timers.get(group_name, 0):
                children = group.get("children", [])
                if children:
                    blink_layer = logic.get("blink", "")
                    open_layer = logic.get("open", "")
                    # Фильтруем доступные слои (только непосредственные дети группы)
                    available = []
                    for child_name in children:
                        # Проверяем, является ли child_name слоем или группой
                        if child_name in [l.get("name") for l in self.model.get("layers", [])]:
                            # Это слой
                            if child_name != blink_layer and child_name != open_layer:
                                available.append(child_name)
                        else:
                            # Это группа, проверяем есть ли в ней видимые слои
                            child_group = next((g for g in self.model.get(
                                "groups", []) if g.get("name") == child_name), None)
                            if child_group and child_group.get("random_effect", False):
                                available.append(child_name)

                    if available:
                        chosen = random.choice(available)
                        self.group_random_current[group_name] = chosen

            interval = random.uniform(min_time, max_time)
            self.group_random_timers[group_name] = now + interval

        if self.group_random_current.get(group_name):
            return self.group_random_current.get(group_name)

        # Обработка голосовых состояний
        current_state_idx = self._get_current_mouth_state_index()

        # Ищем состояние в логике по ключу state_X
        for i, state in enumerate(self.mouth_states):
            state_key = f"state_{i}"
            if state_key in logic and logic[state_key] and current_state_idx == i:
                return logic[state_key]

        # Fallback: если состояния нет в логике, пробуем open или normal
        if "open" in logic and logic["open"]:
            return logic["open"]

        # Если ничего не подошло, возвращаем первый доступный слой из группы
        for layer in self.model.get("layers", []):
            if layer.get("group") == group_name and layer.get("visible", True):
                return layer.get("name")

        return None

    def _get_current_mouth_state_index(self):
        """Определяет текущий индекс состояния рта на основе аудио уровня"""
        if not self.mouth_states:
            return -1

        # Получаем только активные состояния
        active_states = [s for s in self.mouth_states if s.get('active', True)]
        if not active_states:
            return -1  # Все состояния неактивны

        # Находим состояние с максимальным порогом, который не превышает уровень
        current_idx = -1
        for i, state in enumerate(self.mouth_states):
            if state.get('active', True) and self.audio_level >= state.get('threshold', 0.0):
                current_idx = i

        return current_idx

    def _get_all_group_items(self, group_name):
        """Получает все элементы из указанной группы и её дочерних групп"""
        items = []

        # Получаем непосредственные элементы группы
        for ci in self.items:
            if ci.layer.get("group") == group_name:
                items.append(ci)

        # Получаем дочерние группы
        child_groups = [g for g in self.model.get(
            "groups", []) if g.get("parent") == group_name]
        for child_group in child_groups:
            items.extend(self._get_all_group_items(child_group.get("name")))

        return items

    def _get_visible_items_for_state(self, current_state):
        """Возвращает список видимых элементов для текущего состояния с учетом иерархии"""
        visible_items = []
        processed_groups = set()

        # Функция для рекурсивной обработки групп
        def process_group(group_name):
            if group_name in processed_groups:
                return
            processed_groups.add(group_name)

            # Получаем группу
            group = next((g for g in self.model.get("groups", [])
                          if g.get("name") == group_name), None)
            if not group:
                return

            # Получаем текущее состояние для группы
            chosen = self._get_current_state_for_group(group_name)

            if not chosen:
                # Если ничего не выбрано, показываем все видимые слои группы
                for ci in self.items:
                    if ci.layer.get("group") == group_name and ci.visible:
                        visible_items.append(ci)
                return

            # Проверяем, является ли chosen группой или слоем
            is_group = any(g.get("name") ==
                           chosen for g in self.model.get("groups", []))
            if is_group:
                # Если это группа - рекурсивно обрабатываем ее
                process_group(chosen)
            else:
                # Если это слой - добавляем только его в видимые
                for ci in self.items:
                    if ci.layer.get("name") == chosen and ci.layer.get("group") == group_name and ci.visible:
                        visible_items.append(ci)

        # Обрабатываем корневые группы (без родителя)
        root_groups = [g.get("name") for g in self.model.get(
            "groups", []) if not g.get("parent")]
        for group_name in root_groups:
            process_group(group_name)

        # Добавляем элементы без групп
        for ci in self.items:
            if not ci.layer.get("group") and ci.visible:
                visible_items.append(ci)

        return visible_items

    def save_to_history(self, description=""):
        """Сохраняет состояние в историю с использованием UUID"""
        if self.history_index < len(self.history) - 1:
            self.history = self.history[:self.history_index + 1]

        state = {
            'model_snapshot': json.dumps({
                'name': self.model.get('name', ''),
                'width': self.model.get('width', 700),
                'height': self.model.get('height', 700),
                'groups': self.model.get('groups', []),
                'mouth_states': self.mouth_states
            }, ensure_ascii=False),
            'items_changes': [],
            'description': description,
            'timestamp': time.time()
        }

        items_to_save = self.current_selection if self.current_selection else self.items
        for ci in items_to_save:
            item_state = {
                'uuid': ci.uuid,  # Используем UUID вместо id()
                'layer_name': ci.layer.get('name', ''),
                'x': ci.x, 'y': ci.y,
                'scale': ci.scale, 'rotation': ci.rotation,
                'flip_horizontal': ci.flip_horizontal, 'flip_vertical': ci.flip_vertical,
                'visible': ci.visible, 'alpha': ci.alpha,
                'is_gif': ci.is_gif, 'image_path': ci.image_path
            }
            state['items_changes'].append(item_state)

        self.history.append(state)
        self.history_index = len(self.history) - 1
        if len(self.history) > self.max_history_size:
            self.history.pop(0)
            if self.history_index > 0:
                self.history_index -= 1
        logger.info(
            f"History saved: {description}, index: {self.history_index}")

    def load_from_history(self):
        """Загружает состояние из истории и синхронизирует UI"""
        if self.history_index < 0 or self.history_index >= len(self.history):
            return

        state = self.history[self.history_index]
        try:
            for item_state in state['items_changes']:
                item_uuid = item_state.get('uuid')
                # Ищем элемент по UUID
                target_item = next(
                    (ci for ci in self.items if ci.uuid == item_uuid), None)

                if target_item:
                    target_item.x = item_state['x']
                    target_item.y = item_state['y']
                    target_item.scale = item_state['scale']
                    target_item.rotation = item_state['rotation']
                    target_item.flip_horizontal = item_state['flip_horizontal']
                    target_item.flip_vertical = item_state['flip_vertical']
                    target_item.visible = item_state['visible']
                    target_item.alpha = item_state.get('alpha', 1.0)
                    target_item.is_gif = item_state['is_gif']

                    if target_item.layer:
                        target_item.layer.update({
                            'x': item_state['x'], 'y': item_state['y'],
                            'visible': item_state['visible'], 'scale': item_state['scale'],
                            'rotation': item_state['rotation'], 'alpha': item_state.get('alpha', 1.0),
                            'flip_horizontal': item_state['flip_horizontal'],
                            'flip_vertical': item_state['flip_vertical']
                        })
                    target_item.clear_cache()

            if 'model_snapshot' in state:
                model_snapshot = json.loads(state['model_snapshot'])
                self.model['name'] = model_snapshot.get(
                    'name', self.model.get('name', ''))
                self.model['width'] = model_snapshot.get('width', 700)
                self.model['height'] = model_snapshot.get('height', 700)
                self.model['groups'] = model_snapshot.get('groups', [])
                self.mouth_states = model_snapshot.get(
                    'mouth_states', self.mouth_states)

                self.model_name_var.set(self.model['name'])
                self.canvas_width = self.model['width']
                self.canvas_height = self.model['height']
                self.canvas_width_var.set(self.canvas_width)
                self.canvas_height_var.set(self.canvas_height)
                self.refresh_mouth_states_list()

            self._photo_images.clear()
            self._canvas_cache_valid = False
            self.refresh_tree()
            self.redraw_canvas()

            if self.current_selection:
                self.load_item_props(self.current_selection[0])
            else:
                self.clear_props_fields()

        except Exception as e:
            logger.error(f"Error loading from history: {e}")

    def undo(self, event=None):
        if self.history_index > 0:
            self.history_index -= 1
            self.load_from_history()

    def redo(self, event=None):
        if self.history_index < len(self.history) - 1:
            self.history_index += 1
            self.load_from_history()

    def delete_model(self):
        """Удаление текущей модели"""
        if not self.model_dir:
            messagebox.showwarning(
                tr('warning'), tr('no_model'))
            return

        slot_info = ""
        if self.original_slot:
            slot_info = f" из слота {self.original_slot}"

        confirm = messagebox.askyesno(
            tr('delete_confirm_title'),
            f"{tr('delete_confirm', slot=slot_info)}\n\n{tr('delete_confirm')}"
        )

        if not confirm:
            return

        try:
            if self.original_slot:
                slot_dir = os.path.join(
                    MODELS_DIR, f"slot{self.original_slot}")
                if os.path.exists(slot_dir):
                    shutil.rmtree(slot_dir)
                    logger.info(
                        f"Deleted model from slot {self.original_slot}")

            self.model = {"name": tr('default_model_name'), "layers": [],
                          "groups": [], "width": 700, "height": 700}
            self.mouth_states = [
                {'id': 0, 'name': tr('default_state_0'),
                 'threshold': 0.0, 'active': True},
                {'id': 1, 'name': tr('default_state_1'),
                 'threshold': 0.3, 'active': True},
                {'id': 2, 'name': tr('default_state_2'),
                 'threshold': 0.6, 'active': True},
                {'id': 3, 'name': tr('default_state_3'),
                 'threshold': 0.9, 'active': True}
            ]
            self.model_dir = None
            self.original_slot = None
            self.items.clear()
            self.imported_files.clear()
            self.model_name_var.set(tr('default_model_name'))
            self.canvas_width = 700
            self.canvas_height = 700
            self.canvas_width_var.set(700)
            self.canvas_height_var.set(700)

            self.tree_state["expanded_groups"].clear()
            self.tree_state["selected_items"].clear()
            self.tree_state["preserve_selection"] = False

            self.refresh_mouth_states_list()
            self.refresh_tree()
            self.refresh_import_list()
            self.zoom_reset()
            self._canvas_cache_valid = False
            self.redraw_canvas()

            if hasattr(self.master, 'app') and hasattr(self.master.app, 'refresh_slot_buttons'):
                self.master.app.refresh_slot_buttons()

            messagebox.showinfo(tr('model_deleted'), tr(
                'delete_success', slot=slot_info))

        except Exception as e:
            logger.error(f"Error deleting model: {e}")
            messagebox.showerror(tr('error'), tr('delete_error', error=e))

    def export_zip(self):
        """Экспорт модели в ZIP архив с выбором места сохранения"""
        try:
            from utils import export_model_zip
        except Exception as e:
            messagebox.showerror(
                tr('error'), tr('zip_export_error', error=e))
            logger.error(f"Error importing export utility: {e}")
            return

        if not self.model:
            messagebox.showwarning(
                tr('warning'), tr('no_model'))
            return

        default_name = f"{self.model.get('name', 'model').replace(' ', '_')}.zip"
        zip_path = filedialog.asksaveasfilename(
            title=tr('editor_export_zip'),
            defaultextension=".zip",
            filetypes=[("ZIP архивы", "*.zip"), ("Все файлы", "*.*")],
            initialfile=default_name
        )

        if not zip_path:
            return

        try:
            with tempfile.TemporaryDirectory(prefix="model_export_") as temp_dir:
                model_data = {
                    "name": self.model_name_var.get(),
                    "width": self.canvas_width,
                    "height": self.canvas_height,
                    "layers": [],
                    "groups": self.model.get("groups", []),
                    "mouth_states": self.mouth_states  # Сохраняем состояния рта
                }

                for ci in self.items:
                    layer = ci.layer
                    layer_data = {
                        "name": layer.get("name", ""),
                        "file": os.path.basename(layer.get("file", "")),
                        "x": int(ci.x),
                        "y": int(ci.y),
                        "visible": bool(ci.visible),
                        "is_gif": ci.is_gif,
                        "scale": float(ci.scale),
                        "rotation": int(ci.rotation),
                        "alpha": float(ci.alpha),
                        "group": layer.get("group", None),
                        "flip_horizontal": bool(ci.flip_horizontal),
                        "flip_vertical": bool(ci.flip_vertical),
                        "uuid": ci.uuid  # Сохраняем UUID
                    }
                    model_data["layers"].append(layer_data)

                    if hasattr(ci, 'image_path') and os.path.exists(ci.image_path):
                        filename = os.path.basename(ci.image_path)
                        dst = os.path.join(temp_dir, filename)
                        shutil.copy2(ci.image_path, dst)

                json_path = os.path.join(temp_dir, "model.json")
                with open(json_path, "w", encoding="utf-8") as f:
                    json.dump(model_data, f, indent=2, ensure_ascii=False)

                preview_path = os.path.join(temp_dir, "preview.png")
                self._create_preview_for_export(temp_dir, preview_path)

                export_model_zip(model_data, temp_dir, zip_path)

            messagebox.showinfo(
                tr('info'), tr('exported_zip', path=zip_path))
            logger.info(f"Model exported to: {zip_path}")

        except Exception as e:
            import traceback
            tb = traceback.format_exc()
            with open("export_zip_error.log", "w", encoding="utf-8") as f:
                f.write(tb)

            messagebox.showerror(
                tr('error'), tr('zip_export_error', error=e))
            logger.error(f"Error exporting model: {e}\n{tb}")

    def _create_preview_for_export(self, temp_dir, preview_path):
        """Создает превью модели для экспорта"""
        try:
            # Для экспорта используем полные изображения
            base = Image.new("RGBA", (self.canvas_width,
                             self.canvas_height), (0, 0, 0, 0))
            center_x = self.canvas_width // 2
            center_y = self.canvas_height // 2

            visible_items = [ci for ci in self.items if ci.visible]

            for ci in visible_items:
                # Загружаем полное изображение для экспорта
                try:
                    img = Image.open(ci.image_path).convert("RGBA")

                    # Применяем трансформации в ПРАВИЛЬНОМ ПОРЯДКЕ (как в редакторе)
                    if ci.scale != 1.0:
                        new_width = max(1, int(img.width * ci.scale))
                        new_height = max(1, int(img.height * ci.scale))
                        img = img.resize(
                            (new_width, new_height), Image.LANCZOS)

                    if ci.flip_horizontal:
                        img = img.transpose(Image.FLIP_LEFT_RIGHT)
                    if ci.flip_vertical:
                        img = img.transpose(Image.FLIP_TOP_BOTTOM)

                    if ci.rotation != 0:
                        img = img.rotate(
                            ci.rotation, expand=True, resample=Image.BICUBIC)

                    # Применяем прозрачность
                    if ci.alpha < 1.0:
                        if img.mode == 'RGBA':
                            r, g, b, a = img.split()
                            a = a.point(lambda x: int(x * ci.alpha))
                            img = Image.merge('RGBA', (r, g, b, a))

                    px = center_x - img.size[0] // 2 + int(ci.x)
                    py = center_y - img.size[1] // 2 + int(ci.y)

                    base.alpha_composite(img, (px, py))
                except Exception as e:
                    logger.error(f"Error creating preview for export: {e}")

            base.thumbnail((200, 200))
            base.save(preview_path)
        except Exception as e:
            logger.error(f"Error creating preview for export: {e}")

    def import_zip(self):
        """Импорт модели из ZIP архива"""
        try:
            from utils import import_model_zip

            zip_path = filedialog.askopenfilename(
                title=tr('editor_import_zip'),
                filetypes=[("ZIP архивы", "*.zip"), ("Все файлы", "*.*")]
            )

            if not zip_path:
                return

            try:
                model_data, import_dir = import_model_zip(zip_path)

                self.model = model_data
                self.model_dir = import_dir
                self.original_slot = None

                self.model_name_var.set(self.model.get(
                    "name", tr('default_model_name')))

                self.canvas_width = self.model.get("width", 700)
                self.canvas_height = self.model.get("height", 700)
                self.canvas_width_var.set(self.canvas_width)
                self.canvas_height_var.set(self.canvas_height)

                # Загружаем состояния рта
                if 'mouth_states' in model_data and model_data['mouth_states']:
                    self.mouth_states = model_data['mouth_states']
                else:
                    self.mouth_states = [
                        {'id': 0, 'name': tr(
                            'default_state_0'), 'threshold': 0.0, 'active': True},
                        {'id': 1, 'name': tr(
                            'default_state_1'), 'threshold': 0.3, 'active': True},
                        {'id': 2, 'name': tr(
                            'default_state_2'), 'threshold': 0.6, 'active': True},
                        {'id': 3, 'name': tr(
                            'default_state_3'), 'threshold': 0.9, 'active': True}
                    ]

                self.items.clear()
                for layer in self.model.get("layers", []):
                    filename = layer.get("file")
                    if not filename:
                        continue

                    file_path = os.path.join(import_dir, filename)
                    if not os.path.exists(file_path):
                        found = False
                        for root, dirs, files in os.walk(import_dir):
                            if filename in files:
                                file_path = os.path.join(root, filename)
                                found = True
                                break

                        if not found:
                            logger.warning(f"File not found: {filename}")
                            continue

                    try:
                        ci = CanvasItem(layer, file_path)
                        self.items.append(ci)
                    except Exception as e:
                        logger.error(f"Error loading image: {e}")

                self.imported_files.clear()
                for layer in self.model.get("layers", []):
                    filename = layer.get("file")
                    if filename:
                        file_path = os.path.join(import_dir, filename)
                        if os.path.exists(file_path):
                            try:
                                with Image.open(file_path) as img:
                                    is_gif = img.format == "GIF" and img.is_animated
                                    img.seek(0)
                                    preview_img = img.copy().convert("RGBA")
                                    preview_img.thumbnail(
                                        (50, 50), Image.LANCZOS)
                                self.imported_files.append(
                                    (filename, preview_img, is_gif))
                            except Exception as e:
                                logger.error(
                                    f"Error loading imported file: {e}")

                self.refresh_mouth_states_list()
                self.refresh_import_list()

                self.tree_state["expanded_groups"].clear()
                self.tree_state["selected_items"].clear()
                self.tree_state["preserve_selection"] = False

                self.refresh_tree()
                self.zoom_reset()
                self._canvas_cache_valid = False
                self.redraw_canvas()

                self.cleanup_old_temp_folders()

                messagebox.showinfo(
                    tr('info'), tr('imported_zip', path=os.path.basename(zip_path)))
                logger.info(f"Model imported from ZIP: {zip_path}")

            except Exception as e:
                import traceback
                tb = traceback.format_exc()
                messagebox.showerror(
                    tr('error'), tr('zip_import_error', error=e))
                logger.error(f"Error importing model from ZIP: {e}\n{tb}")

        except Exception as e:
            messagebox.showerror(
                tr('error'), tr('zip_import_error', error=e))
            logger.error(f"Error importing import utility: {e}")
            return

    def on_window_resize(self, event):
        """Обработка изменения размера окна - перерисовываем холст"""
        self._canvas_cache_valid = False
        self.redraw_canvas()

    def update_model_name(self, event=None):
        """Обновление имени модели"""
        self.model["name"] = self.model_name_var.get()
        logger.info(f"Model name updated to: {self.model['name']}")

    def redraw_canvas(self, level=0.0, mode="none"):
        """Оптимизированная перерисовка холста"""
        if self._redraw_scheduled:
            return

        self._redraw_scheduled = True

        def do_redraw():
            self._redraw_scheduled = False
            if not self.winfo_exists():
                return

            try:
                # Быстрая очистка
                self.canvas.delete("all")

                # Простой рендеринг без сложных вычислений
                self._fast_render_canvas(level, mode)
            except Exception as e:
                logger.error(f"Redraw error: {e}")

        self.after(self._redraw_delay, do_redraw)

    def _fast_render_canvas(self, level=0.0, mode="none"):
        """Быстрый рендеринг холста"""
        canvas_width = self.canvas.winfo_width()
        canvas_height = self.canvas.winfo_height()

        if canvas_width < 10 or canvas_height < 10:
            return

        # Рассчитываем размеры с учетом зума
        scaled_width = int(self.canvas_width * self.zoom_level)
        scaled_height = int(self.canvas_height * self.zoom_level)

        # Убедитесь, что scaled_width и scaled_height не отрицательные
        scaled_width = max(10, scaled_width)
        scaled_height = max(10, scaled_height)

        center_x = canvas_width // 2 + self.offset_x
        center_y = canvas_height // 2 + self.offset_y

        canvas_x1 = center_x - scaled_width // 2
        canvas_y1 = center_y - scaled_height // 2

        # Рисуем фон холста с учетом границ
        self.canvas.create_rectangle(
            max(0, canvas_x1), max(0, canvas_y1),
            min(canvas_width, canvas_x1 + scaled_width), min(canvas_height,
                                                             canvas_y1 + scaled_height),
            outline="#666", width=2, fill="#333"
        )

        # Определяем список элементов для отображения
        items_to_draw = []

        if mode == "none":
            # Режим редактирования - все видимые слои
            items_to_draw = [ci for ci in self.items if ci.visible]
        else:
            # Режим тестирования - используем логику групп
            # Получаем видимые элементы для текущего состояния
            items_to_draw = self._get_visible_items_for_state(None)

        # Сортируем элементы для правильного наложения (по порядку в self.items)
        items_to_draw.sort(key=lambda x: self.items.index(x))

        # Отрисовываем все элементы
        for ci in items_to_draw:
            img = ci.get_image_for_display(self.zoom_level)
            if img is None:
                continue

            # Рассчитываем позицию на холсте
            center_x_scaled = scaled_width // 2
            center_y_scaled = scaled_height // 2

            # Координаты относительно центра с учетом зума
            offset_x = int(ci.x * self.zoom_level)
            offset_y = int(ci.y * self.zoom_level)

            pos_x = canvas_x1 + center_x_scaled - img.width // 2 + offset_x
            pos_y = canvas_y1 + center_y_scaled - img.height // 2 + offset_y

            # Используем кэшированные PhotoImage, но для GIF не кэшируем
            if ci.is_gif:
                # Для GIF создаем новый PhotoImage каждый раз
                photo = ImageTk.PhotoImage(img)
                # Сохраняем ссылку, чтобы не удалилась сборщиком мусора
                if not hasattr(ci, '_tk_images'):
                    ci._tk_images = []
                ci._tk_images.append(photo)
                # Ограничиваем количество сохраненных изображений
                if len(ci._tk_images) > 5:
                    ci._tk_images.pop(0)
            else:
                # Для статических изображений используем кэш
                photo_key = f"{id(img)}_{self.zoom_level}"
                if photo_key not in self._photo_images:
                    photo = ImageTk.PhotoImage(img)
                    self._photo_images[photo_key] = photo

                    # Ограничиваем размер кэша
                    if len(self._photo_images) > self._photo_cache_limit:
                        oldest = next(iter(self._photo_images))
                        del self._photo_images[oldest]

                photo = self._photo_images[photo_key]

            self.canvas.create_image(pos_x, pos_y, image=photo, anchor="nw")

            # Выделение выбранных элементов (только в режиме редактирования)
            if mode == "none" and ci.layer.get("_selected"):
                self.canvas.create_rectangle(
                    pos_x, pos_y, pos_x + img.width, pos_y + img.height,
                    outline="cyan", width=2
                )

    def cleanup_old_temp_folders(self):
        """Очищает старые временные папки"""
        import re
        import time as tm

        all_folders = [f for f in os.listdir(MODELS_DIR)
                       if os.path.isdir(os.path.join(MODELS_DIR, f))]

        temp_pattern = re.compile(r'^temp_(\d+)_slot(\d+)$')
        model_temp_pattern = re.compile(r'^model_temp_(\d+)$')

        now = tm.time()
        max_age = 3600  # 1 час

        for folder in all_folders:
            folder_path = os.path.join(MODELS_DIR, folder)
            try:
                if temp_pattern.match(folder) or model_temp_pattern.match(folder):
                    # Проверяем время создания
                    stat = os.stat(folder_path)
                    if now - stat.st_mtime > max_age:
                        shutil.rmtree(folder_path)
                        logger.info(f"Removed old temp folder: {folder}")
            except Exception as e:
                logger.error(f"Error checking temp folder {folder}: {e}")

    def group_selected(self):
        """Создает группу из выбранных элементов"""
        if not self.current_selection:
            messagebox.showwarning(tr('warning'), tr('editor_group'))
            return

        name = simpledialog.askstring(
            tr('editor_group'), tr('editor_name'), parent=self)
        if not name:
            return

        existing = [g.get("name") for g in self.model.get("groups", [])]
        if name in existing:
            messagebox.showwarning(
                tr('warning'), tr('group_created', name=name))
            return

        # Определяем родительскую группу (если все выбранные элементы из одной группы)
        parent_group = None
        selected_groups = set()
        for ci in self.current_selection:
            group_name = ci.layer.get("group")
            if group_name:
                selected_groups.add(group_name)

        if len(selected_groups) == 1:
            parent_group = list(selected_groups)[0]
        elif self.selected_group:
            # Если выбрана группа в интерфейсе, используем ее как родительскую
            parent_group = self.selected_group

        new_group = {
            "name": name,
            "children": [ci.layer.get("name") for ci in self.current_selection],
            "parent": parent_group,
            "logic": {},
            "blink_freq": 0.0,
            "random_effect": False,
            "random_min": 5.0,
            "random_max": 10.0
        }

        self.model.setdefault("groups", []).append(new_group)

        for ci in self.current_selection:
            ci.layer["group"] = name

        # Обновляем родительскую группу (если есть)
        if parent_group:
            for g in self.model.get("groups", []):
                if g.get("name") == parent_group:
                    # Удаляем элементы из родительской группы
                    for ci in self.current_selection:
                        if ci.layer.get("name") in g.get("children", []):
                            g["children"].remove(ci.layer.get("name"))
                    # Добавляем новую группу как дочерний элемент
                    g["children"].append(name)
                    break

        self._save_tree_state()
        self.tree_state["preserve_selection"] = True

        for ci in self.items:
            ci.layer["_selected"] = False
        self.current_selection = []
        self.selected_group = name
        self.refresh_tree()
        self._canvas_cache_valid = False
        self.redraw_canvas()

        logger.info(tr('group_created', name=name))
        self.save_to_history(tr('group_created', name=name))

    def _save_tree_state(self):
        """Сохраняет состояние дерева"""
        self.tree_state["expanded_groups"].clear()
        self.tree_state["selected_items"].clear()

        for item in self.tree.get_children():
            if self.tree.item(item, "open"):
                values = self.tree.item(item, "values")
                if values and values[0] == "group":
                    self.tree_state["expanded_groups"].add(values[1])

        for item in self.tree.selection():
            values = self.tree.item(item, "values")
            if values:
                self.tree_state["selected_items"].add(tuple(values))

    def _restore_tree_state(self):
        """Восстанавливает состояние дерева"""
        for item in self.tree.get_children():
            values = self.tree.item(item, "values")
            if values and values[0] == "group" and values[1] in self.tree_state["expanded_groups"]:
                self.tree.item(item, open=True)

        if self.tree_state["preserve_selection"]:
            for item in self.tree.get_children():
                values = self.tree.item(item, "values")
                if values and tuple(values) in self.tree_state["selected_items"]:
                    self.tree.selection_add(item)

            self.tree_state["preserve_selection"] = False

    def refresh_tree(self):
        """Обновляет дерево элементов"""
        try:
            # Сохраняем текущее выделение
            selected_ids = []
            for ci in self.current_selection:
                selected_ids.append(id(ci))

            self._save_tree_state()

            self.tree.delete(*self.tree.get_children())

            groups_by_name = {
                g.get("name"): g for g in self.model.get("groups", [])}
            group_nodes = {}
            items_added = set()

            # Функция для получения пути группы (от корня до текущей группы)
            def get_group_path(group_name):
                path = []
                current = group_name
                while current:
                    path.insert(0, current)
                    group = groups_by_name.get(current)
                    current = group.get("parent") if group else None
                return path

            # Создаем узлы для всех групп (если они еще не созданы)
            def ensure_group_node(group_name):
                if group_name in group_nodes:
                    return group_nodes[group_name]

                group = groups_by_name.get(group_name)
                if not group:
                    return None

                # Получаем путь группы
                path = get_group_path(group_name)

                # Создаем узлы для всех групп в пути
                parent_node = ""
                for group_in_path in path:
                    if group_in_path in group_nodes:
                        parent_node = group_nodes[group_in_path]
                        continue

                    # Создаем узел для этой группы
                    group_node = self.tree.insert(parent_node, "end", text=f"📁 {group_in_path}",
                                                  values=("group", group_in_path))
                    group_nodes[group_in_path] = group_node
                    parent_node = group_node

                return group_nodes[group_name]

            # Проходим по элементам в ОБРАТНОМ порядке
            for ci in reversed(self.items):
                item_id = id(ci)
                if item_id in items_added:
                    continue

                group_name = ci.layer.get("group")

                if group_name:
                    # Убеждаемся, что узел группы существует
                    group_node = ensure_group_node(group_name)
                    if group_node:
                        # Добавляем элемент в группу
                        self.tree.insert(group_node, "end",
                                         text=self._get_item_display_text(ci),
                                         values=("item", item_id))
                        items_added.add(item_id)
                    else:
                        # Группа не найдена, добавляем в корень
                        self.tree.insert("", "end", text=self._get_item_display_text(ci),
                                         values=("item", item_id))
                        items_added.add(item_id)
                else:
                    # Элемент без группы - добавляем в корень
                    self.tree.insert("", "end", text=self._get_item_display_text(ci),
                                     values=("item", item_id))
                    items_added.add(item_id)

            self._restore_tree_state()

            # Восстанавливаем выделение
            self.current_selection = []
            for ci in self.items:
                if id(ci) in selected_ids:
                    ci.layer["_selected"] = True
                    self.current_selection.append(ci)
                    # Выделяем в дереве
                    self._select_item_in_tree(ci)

        except Exception as e:
            logger.error(f"Error refreshing tree: {e}")

    def _get_item_display_text(self, ci):
        """Генерирует текст для отображения элемента в дереве"""
        layer = ci.layer
        name = layer.get("name", "unnamed")
        flags = []

        if not ci.visible:
            flags.append("✘")
        else:
            flags.append("✔")

        if ci.is_gif:
            flags.append("GIF")

        if ci.flip_horizontal:
            flags.append("зерк.гор")

        if ci.flip_vertical:
            flags.append("зерк.верт")

        if ci.rotation != 0:
            flags.append(f"↻{ci.rotation}°")

        if ci.scale != 1.0:
            flags.append(f"⤢{ci.scale}")

        if ci.alpha < 1.0:
            flags.append(f"α{ci.alpha:.1f}")

        flag_text = f" ({', '.join(flags)})" if flags else ""
        return f"{name}{flag_text}"

    def _get_item_by_id(self, item_id):
        """Находит элемент по ID"""
        for ci in self.items:
            if id(ci) == item_id:
                return ci
        return None

    def _select_item_in_tree(self, canvas_item):
        """Выделяет элемент в дереве по CanvasItem"""
        # Находим ID элемента в дереве
        for item_id in self.tree.get_children():
            values = self.tree.item(item_id, "values")
            if values and values[0] == "item":
                item_id_int = int(values[1])
                if item_id_int == id(canvas_item):
                    self.tree.selection_set(item_id)
                    self.tree.focus(item_id)
                    # Прокручиваем к выбранному элементу
                    self.tree.see(item_id)
                    return

        # Проверяем дочерние элементы (для элементов в группах)
        for parent_id in self.tree.get_children():
            for child_id in self.tree.get_children(parent_id):
                values = self.tree.item(child_id, "values")
                if values and values[0] == "item":
                    item_id_int = int(values[1])
                    if item_id_int == id(canvas_item):
                        self.tree.selection_set(child_id)
                        self.tree.focus(child_id)
                        # Раскрываем родительскую группу
                        self.tree.item(parent_id, open=True)
                        # Прокручиваем к выбранному элементу
                        self.tree.see(child_id)
                        return

    def _select_group_in_tree(self, group_name):
        """Выделяет группу в дереве элементов"""
        self.tree.selection_remove(self.tree.selection())

        def search_group(parent):
            for item_id in self.tree.get_children(parent):
                values = self.tree.item(item_id, "values")
                if values and values[0] == "group" and values[1] == group_name:
                    self.tree.selection_set(item_id)
                    self.tree.focus(item_id)
                    self.tree.item(item_id, open=True)
                    self.tree.see(item_id)
                    return True
                if search_group(item_id):
                    return True
            return False

        search_group("")

    def on_tree_select(self, event=None):
        """Обработчик выбора в дереве"""
        try:
            focus_widget = self.focus_get()
            if isinstance(focus_widget, (ttk.Entry, tk.Entry, ttk.Combobox)):
                return

            selection = self.tree.selection()
            self.current_selection = []
            self.selected_group = None

            for c in self.items:
                c.layer["_selected"] = False

            if not selection:
                self.group_label.config(text=tr('editor_no_group'))
                self.clear_props_fields()
                self._canvas_cache_valid = False
                self.redraw_canvas()
                return

            selected_groups = set()
            selected_items = set()

            for item_id in selection:
                item_values = self.tree.item(item_id, "values")
                if not item_values:
                    continue

                if item_values[0] == "group":
                    group_name = item_values[1]
                    selected_groups.add(group_name)

                    # Рекурсивно получаем все элементы группы и её дочерних групп
                    group_items = self._get_all_items_in_group_recursive(
                        group_name)
                    for ci in group_items:
                        ci.layer["_selected"] = True
                        selected_items.add(ci)
                elif item_values[0] == "item":
                    item_id_int = int(item_values[1])
                    ci = self._get_item_by_id(item_id_int)
                    if ci:
                        ci.layer["_selected"] = True
                        selected_items.add(ci)

            self.current_selection = list(selected_items)

            if len(selected_groups) == 1:
                self.selected_group = list(selected_groups)[0]
                self.group_label.config(text=self.selected_group)
                self.load_group_settings(self.selected_group)
            else:
                self.selected_group = None
                self.group_label.config(text=tr('editor_no_group'))
                if self.current_selection:
                    self.load_item_props(self.current_selection[0])
                else:
                    self.clear_props_fields()

            self._canvas_cache_valid = False
            self.redraw_canvas()

        except Exception as e:
            logger.error(f"Error in on_tree_select: {e}")

    def bring_forward(self):
        """Перемещает выделенные элементы вперед"""
        if not self.current_selection:
            return

        # Сортируем по текущей позиции
        sorted_items = sorted(self.current_selection,
                              key=lambda x: self.items.index(x), reverse=True)

        for ci in sorted_items:
            idx = self.items.index(ci)
            if idx < len(self.items) - 1:
                # Меняем местами со следующим элементом
                self.items[idx], self.items[idx +
                                            1] = self.items[idx + 1], self.items[idx]

        self._save_tree_state()
        self.tree_state["preserve_selection"] = True

        self.refresh_tree()
        self._canvas_cache_valid = False
        self.redraw_canvas()

        logger.info("Brought selection forward")
        self.save_to_history(tr('editor_bring_forward'))

    def send_backward(self):
        """Перемещает выделенные элементы назад"""
        if not self.current_selection:
            return

        # Сортируем по текущей позиции
        sorted_items = sorted(self.current_selection,
                              key=lambda x: self.items.index(x))

        for ci in sorted_items:
            idx = self.items.index(ci)
            if idx > 0:
                # Меняем местами с предыдущим элементом
                self.items[idx], self.items[idx -
                                            1] = self.items[idx - 1], self.items[idx]

        self._save_tree_state()
        self.tree_state["preserve_selection"] = True

        self.refresh_tree()
        self._canvas_cache_valid = False
        self.redraw_canvas()

        logger.info("Sent selection backward")
        self.save_to_history(tr('editor_send_backward'))

    def delete_selected_items(self):
        """Удаляет выбранные элементы с холста"""
        if not self.current_selection:
            messagebox.showwarning(tr('warning'), tr('editor_delete_selected'))
            return

        confirm = messagebox.askyesno(
            tr('delete_confirm_title'),
            f"Вы уверены, что хотите удалить {len(self.current_selection)} выбранных элементов?"
        )

        if not confirm:
            return

        # Удаляем выбранные элементы из списка items
        items_to_remove = set(self.current_selection)
        self.items = [ci for ci in self.items if ci not in items_to_remove]

        # Удаляем соответствующие слои из модели
        layer_names_to_remove = {ci.layer.get(
            "name") for ci in items_to_remove}
        self.model["layers"] = [layer for layer in self.model.get("layers", [])
                                if layer.get("name") not in layer_names_to_remove]

        # Обновляем группы: удаляем ссылки на удаленные слои
        for group in self.model.get("groups", []):
            if "children" in group:
                group["children"] = [child for child in group["children"]
                                     if child not in layer_names_to_remove]

        # Сбрасываем выделение
        for ci in self.current_selection:
            if hasattr(ci, '_tk_images'):
                ci._tk_images.clear()

        self.current_selection = []
        self.clear_props_fields()

        # Обновляем интерфейс
        self._save_tree_state()
        self.tree_state["preserve_selection"] = False

        self.refresh_tree()
        self._canvas_cache_valid = False
        self.redraw_canvas()

        logger.info(f"Deleted {len(items_to_remove)} selected items")
        self.save_to_history(tr('editor_delete_selected'))

    def update_group_logic_menus(self, group_name):
        """Обновляет меню логики группы - динамически на основе состояний рта"""
        group = next((g for g in self.model.get("groups", [])
                      if g.get("name") == group_name), None)
        if not group:
            return

        # Собираем ВСЕ доступные опции:
        # 1. Слои этой группы
        # 2. Дочерние группы
        # 3. Слои из дочерних групп (рекурсивно)
        options = [""]  # Пустая опция для очистки

        # Функция для рекурсивного сбора всех слоев из группы и ее дочерних групп
        def collect_group_items(group_name, indent=""):
            items = []

            # Собираем слои этой группы
            for layer in self.model.get("layers", []):
                if layer.get("group") == group_name:
                    display_name = f"{indent}📄 {layer.get('name')}"
                    items.append((display_name, layer.get('name'), "layer"))

            # Собираем дочерние группы
            for g in self.model.get("groups", []):
                if g.get("parent") == group_name:
                    child_name = g.get("name")
                    display_name = f"{indent}📁 {child_name}"
                    items.append((display_name, child_name, "group"))
                    # Рекурсивно собираем элементы из дочерней группы
                    items.extend(collect_group_items(
                        child_name, indent + "   "))

            return items

        # Собираем все элементы
        all_items = collect_group_items(group_name)

        # Обновляем меню для каждого состояния рта
        for i, state in enumerate(self.mouth_states):
            state_key = f"state_{i}"
            menu_widget = getattr(self, f"{state_key}_menu", None)
            if menu_widget:
                menu = menu_widget['menu']
                menu.delete(0, 'end')

                # Добавляем пустую опцию
                menu.add_command(
                    label=tr('editor_empty'),
                    command=lambda v=self.state_vars[state_key], val="": v.set(
                        val)
                )

                # Добавляем все собранные элементы
                for display_name, real_name, item_type in all_items:
                    menu.add_command(
                        label=display_name,
                        command=lambda v=self.state_vars[state_key], val=real_name: v.set(
                            val)
                    )

        # Обновляем меню для blink
        blink_menu_widget = getattr(self, "blink_menu", None)
        if blink_menu_widget:
            menu = blink_menu_widget['menu']
            menu.delete(0, 'end')
            menu.add_command(
                label=tr('editor_empty'), command=lambda v=self.blink_var, val="": v.set(val))
            for display_name, real_name, item_type in all_items:
                menu.add_command(
                    label=display_name, command=lambda v=self.blink_var, val=real_name: v.set(val))

        # Обновляем меню для open
        open_menu_widget = getattr(self, "open_menu", None)
        if open_menu_widget:
            menu = open_menu_widget['menu']
            menu.delete(0, 'end')
            menu.add_command(
                label=tr('editor_empty'), command=lambda v=self.open_var, val="": v.set(val))
            for display_name, real_name, item_type in all_items:
                menu.add_command(
                    label=display_name, command=lambda v=self.open_var, val=real_name: v.set(val))

        logger.debug(
            f"Updated group logic menus for {group_name}, items: {len(all_items)}")

    def apply_group_logic(self):
        """Применяет логику группы"""
        if not self.selected_group:
            messagebox.showwarning(tr('warning'), tr('editor_group_logic'))
            return

        group_name = self.selected_group
        group = None

        for g in self.model.get("groups", []):
            if g.get("name") == group_name:
                group = g
                break

        if not group:
            messagebox.showerror(tr('error'), tr(
                'group_deleted', name=group_name))
            return

        # Сохраняем логику состояний рта
        logic = {}
        for i, state in enumerate(self.mouth_states):
            state_key = f"state_{i}"
            val = self.state_vars.get(state_key, tk.StringVar()).get().strip()
            if val:
                logic[state_key] = val

        # Сохраняем blink и open
        blink_val = self.blink_var.get().strip()
        if blink_val:
            logic['blink'] = blink_val
        open_val = self.open_var.get().strip()
        if open_val:
            logic['open'] = open_val

        group["logic"] = logic

        # Сохраняем настройки моргания
        try:
            blink_freq = self.blink_freq.get()
            if blink_freq == "":
                blink_freq = 0.0
            group["blink_freq"] = float(blink_freq)
        except Exception as e:
            logger.error(f"Error converting blink_freq: {e}")
            group["blink_freq"] = 0.0

        # Сохраняем настройки случайного эффекта
        group["random_effect"] = self.random_effect_var.get()
        group["random_min"] = self.random_min_var.get()
        group["random_max"] = self.random_max_var.get()

        self._save_tree_state()
        self.tree_state["preserve_selection"] = True

        messagebox.showinfo(
            tr('info'), tr('group_logic_applied', name=group_name))
        logger.info(f"Group logic applied to {group_name}")

    def on_mirror_change(self):
        """Обработчик изменения отражения"""
        if not self.current_selection:
            return

        for ci in self.current_selection:
            ci.flip_horizontal = self.flip_h_var.get()
            ci.flip_vertical = self.flip_v_var.get()
            ci.clear_cache()  # Очищаем кэш

        # Очищаем кэш редактора
        self._photo_images.clear()
        self._canvas_cache_valid = False
        self.redraw_canvas()
        self.save_to_history(tr('editor_mirror'))

    def on_visible_change(self):
        """Обработчик изменения видимости"""
        if not self.current_selection:
            return

        for ci in self.current_selection:
            ci.visible = self.visible_var.get()
            ci.clear_cache()  # Очищаем кэш

        # Очищаем кэш редактора
        self._photo_images.clear()
        self._canvas_cache_valid = False
        self.redraw_canvas()
        self.save_to_history(tr('editor_visible'))

    def zoom_in(self):
        """Увеличивает масштаб"""
        self.zoom_level = min(self.max_zoom, self.zoom_level + self.zoom_step)
        self._canvas_cache_valid = False
        self.redraw_canvas()

    def zoom_out(self):
        """Уменьшает масштаб"""
        self.zoom_level = max(self.min_zoom, self.zoom_level - self.zoom_step)
        self._canvas_cache_valid = False
        self.redraw_canvas()

    def zoom_reset(self):
        """Сбрасывает масштаб"""
        self.zoom_level = 1.0
        self.offset_x = 0
        self.offset_y = 0
        self._canvas_cache_valid = False
        self.redraw_canvas()

    def on_canvas_zoom(self, event):
        """Обработчик зума колесиком мыши"""
        if event.delta > 0 or event.num == 4:
            self.zoom_in()
        else:
            self.zoom_out()

    def on_canvas_pan_start(self, event):
        """Начало панорамирования"""
        self.is_panning = True
        self.last_pan_x = event.x
        self.last_pan_y = event.y
        self.canvas.config(cursor="fleur")

    def on_canvas_pan_move(self, event):
        """Панорамирование"""
        if self.is_panning:
            dx = event.x - self.last_pan_x
            dy = event.y - self.last_pan_y
            self.offset_x += dx
            self.offset_y += dy
            self.last_pan_x = event.x
            self.last_pan_y = event.y
            self._canvas_cache_valid = False
            self.redraw_canvas()

    def on_canvas_pan_end(self, event):
        """Конец панорамирования"""
        self.is_panning = False
        self.canvas.config(cursor="crosshair")

    def update_canvas_size(self, event=None):
        """Обновляет размер холста"""
        try:
            # Сохраняем в историю перед изменением
            self.save_to_history(tr('editor_canvas_settings'))

            new_width = max(100, min(1500, self.canvas_width_var.get()))
            new_height = max(100, min(1500, self.canvas_height_var.get()))
            self.canvas_width = new_width
            self.canvas_height = new_height
            self.canvas_width_var.set(new_width)
            self.canvas_height_var.set(new_height)
            self.model["width"] = new_width
            self.model["height"] = new_height
            self.zoom_reset()
            self._canvas_cache_valid = False
            logger.info(f"Canvas size updated to: {new_width}x{new_height}")
        except Exception as e:
            messagebox.showerror(tr('error'), f"Неверный размер холста: {e}")
            logger.error(f"Error updating canvas size: {e}")

    def on_close(self):
        """Закрытие редактора"""
        try:
            self.audio_processor.stop()
            self.stop_blink_preview()
        except Exception as e:
            logger.error(f"Error stopping audio: {e}")

        # Удаляем временную папку
        if self.model_dir and "temp_" in self.model_dir and os.path.exists(self.model_dir):
            try:
                shutil.rmtree(self.model_dir)
                logger.info(f"Temporary directory removed: {self.model_dir}")
            except Exception as e:
                logger.error(f"Error removing temporary directory: {e}")

        # Отписываемся от обновлений языка
        i18n.unregister_callback(self.refresh_ui_texts)
        self.grab_release()
        logger.info("Model editor closed")
        self.destroy()

    def update_test_mode(self):
        """Обновляет режим тестирования"""
        mode = self.test_mode_var.get()

        if mode == "none":
            self.level_frame.pack_forget()
            self.audio_processor.stop()
            self.audio_level = 0.0
            self.level_bar["value"] = 0
        else:
            self.level_frame.pack(fill="x", pady=5)

            if mode == "microphone":
                try:
                    self.audio_processor.stop()
                    self.audio_processor = AudioProcessor(
                        callback=self.on_audio_level,
                        device=self.mic_device
                    )
                    self.audio_processor.noise_gate_threshold = self.mic_noise_gate_threshold
                    self.audio_processor.set_sensitivity(self.mic_sensitivity)
                    self.audio_processor.start()
                except Exception as e:
                    logger.error(f"Error starting audio processor: {e}")

    def on_audio_level(self, level):
        """Обработчик уровня аудио"""
        level_scaled = level * self.mic_sensitivity
        if self.test_mode_var.get() == "microphone":
            self.level_bar["value"] = level_scaled * 100
        self.audio_level = level_scaled

    def new_model(self):
        """Создает новую модель"""
        name = simpledialog.askstring(
            tr('editor_new'), tr('editor_model_name'), parent=self)
        if not name:
            return

        self.model = {"name": name, "layers": [],
                      "groups": [], "width": 700, "height": 700}
        self.mouth_states = [
            {'id': 0, 'name': tr('default_state_0'),
             'threshold': 0.0, 'active': True},
            {'id': 1, 'name': tr('default_state_1'),
             'threshold': 0.3, 'active': True},
            {'id': 2, 'name': tr('default_state_2'),
             'threshold': 0.6, 'active': True},
            {'id': 3, 'name': tr('default_state_3'),
             'threshold': 0.9, 'active': True}
        ]
        self.model_dir = None
        self.original_slot = None
        self.items.clear()
        self.imported_files.clear()
        self.model_name_var.set(name)
        self.canvas_width = 700
        self.canvas_height = 700
        self.canvas_width_var.set(700)
        self.canvas_height_var.set(700)
        self.refresh_mouth_states_list()
        self.refresh_import_list()

        self.tree_state["expanded_groups"].clear()
        self.tree_state["selected_items"].clear()
        self.tree_state["preserve_selection"] = False

        self.refresh_tree()
        self.zoom_reset()
        self._canvas_cache_valid = False
        self.redraw_canvas()

        logger.info(f"New model created: {name}")

    def load_model(self):
        """Загружает модель из слота"""
        slot_dialog = tk.Toplevel(self)
        slot_dialog.title(tr('editor_load'))
        slot_dialog.geometry("400x500")
        slot_dialog.transient(self)
        slot_dialog.grab_set()
        slot_dialog.resizable(False, False)

        slot_dialog.images = []

        ttk.Label(slot_dialog, text=tr('editor_load'),
                  font=("Arial", 10, "bold")).pack(pady=10)

        main_frame = ttk.Frame(slot_dialog)
        main_frame.pack(fill="both", expand=True, padx=10, pady=5)

        canvas = tk.Canvas(main_frame)
        scrollbar = ttk.Scrollbar(
            main_frame, orient="vertical", command=canvas.yview)
        canvas.configure(yscrollcommand=scrollbar.set)

        scrollbar.pack(side="right", fill="y")
        canvas.pack(side="left", fill="both", expand=True)

        inner_frame = ttk.Frame(canvas)
        canvas.create_window((0, 0), window=inner_frame,
                             anchor="nw", width=380)

        def configure_scrollregion(event):
            canvas.configure(scrollregion=canvas.bbox("all"))

        inner_frame.bind("<Configure>", configure_scrollregion)

        # Превью текущей модели
        current_preview_frame = ttk.LabelFrame(
            inner_frame, text=tr('editor_preview'))
        current_preview_frame.pack(fill="x", pady=(0, 10), padx=5)

        current_preview_label = ttk.Label(current_preview_frame)
        current_preview_label.pack(padx=5, pady=5)

        try:
            if self.model_dir:
                preview_path = os.path.join(self.model_dir, "preview.png")
                if os.path.exists(preview_path):
                    img = Image.open(preview_path)
                    img.thumbnail((150, 150), Image.LANCZOS)
                    current_preview_img = ImageTk.PhotoImage(img)
                    slot_dialog.images.append(current_preview_img)
                    current_preview_label.configure(image=current_preview_img)
                else:
                    img = Image.new("RGBA", (150, 150), (0, 0, 0, 0))
                    current_preview_img = ImageTk.PhotoImage(img)
                    slot_dialog.images.append(current_preview_img)
                    current_preview_label.configure(image=current_preview_img)
        except Exception as e:
            logger.error(f"Error loading current preview: {e}")

        # Слоты
        slots_frame = ttk.Frame(inner_frame)
        slots_frame.pack(fill="both", expand=True, padx=5, pady=5)

        for i in range(1, 7):
            slot_frame = ttk.LabelFrame(slots_frame, text=f"{tr('slot')} {i}")
            slot_frame.pack(fill="x", pady=5, padx=5)

            content_frame = ttk.Frame(slot_frame)
            content_frame.pack(fill="x", padx=5, pady=5)

            # Превью слота
            try:
                preview_path = os.path.join(
                    MODELS_DIR, f"slot{i}", "preview.png")
                if os.path.exists(preview_path):
                    img = Image.open(preview_path)
                    img.thumbnail((80, 80), Image.LANCZOS)
                    preview_img = ImageTk.PhotoImage(img)
                    slot_dialog.images.append(preview_img)

                    preview_label = ttk.Label(content_frame, image=preview_img)
                    preview_label.pack(side="left", padx=5, pady=5)
                else:
                    img = Image.new("RGBA", (80, 80), (0, 0, 0, 0))
                    preview_img = ImageTk.PhotoImage(img)
                    slot_dialog.images.append(preview_img)

                    preview_label = ttk.Label(content_frame, image=preview_img)
                    preview_label.pack(side="left", padx=5, pady=5)
            except Exception as e:
                logger.error(f"Error loading preview for slot {i}: {e}")

            # Информация о слоте
            info_frame = ttk.Frame(content_frame)
            info_frame.pack(side="left", fill="both", expand=True, padx=5)

            slot_dir = os.path.join(MODELS_DIR, f"slot{i}")
            json_path = os.path.join(slot_dir, "model.json")

            if os.path.exists(json_path):
                try:
                    with open(json_path, "r", encoding="utf-8") as f:
                        model_data = json.load(f)
                    model_name = model_data.get('name', f"{tr('slot')} {i}")
                    status_text = model_name
                except:
                    status_text = tr('error')
            else:
                status_text = tr('empty_slot')

            status = ttk.Label(info_frame, text=status_text, font=("Arial", 9))
            status.pack(anchor="w", pady=(5, 0))

            # Кнопка загрузки
            btn = ttk.Button(
                info_frame,
                text=tr('editor_load'),
                command=lambda slot=i, dlg=slot_dialog: self._load_slot(
                    slot, dlg)
            )
            btn.pack(anchor="w", pady=5)

        ttk.Button(slot_dialog, text=tr('port_dialog_cancel'),
                   command=slot_dialog.destroy).pack(pady=10)

        slot_dialog.update()

    def _load_slot(self, slot_num, dialog):
        """Загружает модель из слота"""
        dialog.destroy()
        path = os.path.join(MODELS_DIR, f"slot{slot_num}")
        json_path = os.path.join(path, "model.json")

        if not os.path.exists(json_path):
            messagebox.showerror(
                tr('error'), "model.json не найден в выбранном слоте")
            return

        with open(json_path, "r", encoding="utf-8") as f:
            self.model = json.load(f)

        self.model_name_var.set(self.model.get(
            "name", tr('default_model_name')))

        self.canvas_width = self.model.get("width", 700)
        self.canvas_height = self.model.get("height", 700)
        self.canvas_width_var.set(self.canvas_width)
        self.canvas_height_var.set(self.canvas_height)

        # Загружаем состояния рта
        if 'mouth_states' in self.model and self.model['mouth_states']:
            self.mouth_states = self.model['mouth_states']
        else:
            self.mouth_states = [
                {'id': 0, 'name': tr('default_state_0'),
                 'threshold': 0.0, 'active': True},
                {'id': 1, 'name': tr('default_state_1'),
                 'threshold': 0.3, 'active': True},
                {'id': 2, 'name': tr('default_state_2'),
                 'threshold': 0.6, 'active': True},
                {'id': 3, 'name': tr('default_state_3'),
                 'threshold': 0.9, 'active': True}
            ]

        # Создаем временную папку
        temp_dir = os.path.join(
            MODELS_DIR, f"temp_{int(time.time())}_slot{slot_num}")
        os.makedirs(temp_dir, exist_ok=True)

        # Копируем файлы
        for f in os.listdir(path):
            src = os.path.join(path, f)
            if os.path.isfile(src):
                shutil.copy2(src, os.path.join(temp_dir, f))

        self.model_dir = temp_dir
        self.original_slot = slot_num

        # Загружаем элементы
        self.items.clear()

        # Очищаем выделение и группу
        self.current_selection = []
        self.selected_group = None

        # Очищаем кэш изображений редактора
        self._photo_images.clear()

        # Сбрасываем таймеры групп
        self.group_blink_timers.clear()
        self.group_blink_until.clear()
        self.group_random_timers.clear()
        self.group_random_current.clear()

        for layer in self.model.get("layers", []):
            filename = layer.get("file")
            if not filename:
                continue

            file_path = os.path.join(self.model_dir, filename)
            if not os.path.exists(file_path):
                continue

            try:
                ci = CanvasItem(layer, file_path)
                self.items.append(ci)
            except Exception as e:
                logger.error(f"Error loading image: {e}")

        # Загружаем список импортированных файлов
        self.imported_files.clear()
        for f in os.listdir(self.model_dir):
            if f.lower().endswith((".png", ".gif")):
                try:
                    fp = os.path.join(self.model_dir, f)
                    with Image.open(fp) as img:
                        is_gif = img.format == "GIF" and img.is_animated
                        img.seek(0)
                        preview_img = img.copy().convert("RGBA")
                        preview_img.thumbnail((50, 50), Image.LANCZOS)
                    self.imported_files.append((f, preview_img, is_gif))
                except Exception as e:
                    logger.error(f"Error loading imported file: {e}")

        self.refresh_mouth_states_list()
        self.refresh_import_list()

        self.tree_state["expanded_groups"].clear()
        self.tree_state["selected_items"].clear()
        self.tree_state["preserve_selection"] = False

        self.refresh_tree()
        self.zoom_reset()
        self._canvas_cache_valid = False
        self.redraw_canvas()

        self.cleanup_old_temp_folders()

        logger.info(f"Model loaded from slot {slot_num}")

    def save_model(self):
        """Сохраняет модель"""
        if not self.model_dir:
            tmp = os.path.join(MODELS_DIR, f"model_temp_{int(time.time())}")
            os.makedirs(tmp, exist_ok=True)
            self.model_dir = tmp

            self.cleanup_old_temp_folders()

        self.model["name"] = self.model_name_var.get()
        self.model["width"] = self.canvas_width
        self.model["height"] = self.canvas_height
        # Сохраняем состояния рта
        self.model["mouth_states"] = self.mouth_states

        # Обновляем данные слоев
        self.model["layers"] = []
        for ci in self.items:
            layer = ci.layer.copy() if ci.layer else {}
            layer["x"] = int(ci.x)
            layer["y"] = int(ci.y)
            layer["visible"] = bool(ci.visible)
            layer["is_gif"] = ci.is_gif
            layer["scale"] = float(ci.scale)
            layer["rotation"] = int(ci.rotation)
            layer["alpha"] = float(ci.alpha)
            layer["flip_horizontal"] = bool(ci.flip_horizontal)
            layer["flip_vertical"] = bool(ci.flip_vertical)
            layer["uuid"] = ci.uuid  # Сохраняем UUID

            if "file" in layer:
                layer["file"] = os.path.basename(layer["file"])

            if not layer.get("name") and ci.layer and ci.layer.get("name"):
                layer["name"] = ci.layer.get("name")

            self.model["layers"].append(layer)

        # Сохраняем JSON
        model_json_path = os.path.join(self.model_dir, "model.json")
        try:
            with open(model_json_path, "w", encoding="utf-8") as f:
                json.dump(self.model, f, indent=2, ensure_ascii=False)
        except Exception as e:
            logger.error(f"Error saving model JSON: {e}")
            messagebox.showerror(
                tr('error'), f"Не удалось сохранить модель: {e}")
            return

        # Создаем превью
        self.create_preview()

        # Показываем диалог выбора слота
        self.show_save_slot_dialog()

        self.last_autosave = time.time()
        logger.info("Model saved, showing slot selection dialog with previews")

    def show_save_slot_dialog(self):
        """Показывает диалог сохранения в слот"""
        slot_dialog = tk.Toplevel(self)
        slot_dialog.title(tr('editor_save'))
        slot_dialog.geometry("400x500")
        slot_dialog.transient(self)
        slot_dialog.grab_set()
        slot_dialog.resizable(False, False)

        slot_dialog.images = []

        ttk.Label(slot_dialog, text=tr('editor_save'),
                  font=("Arial", 10, "bold")).pack(pady=10)

        main_frame = ttk.Frame(slot_dialog)
        main_frame.pack(fill="both", expand=True, padx=10, pady=5)

        canvas = tk.Canvas(main_frame)
        scrollbar = ttk.Scrollbar(
            main_frame, orient="vertical", command=canvas.yview)
        canvas.configure(yscrollcommand=scrollbar.set)

        scrollbar.pack(side="right", fill="y")
        canvas.pack(side="left", fill="both", expand=True)

        inner_frame = ttk.Frame(canvas)
        canvas.create_window((0, 0), window=inner_frame,
                             anchor="nw", width=380)

        def configure_scrollregion(event):
            canvas.configure(scrollregion=canvas.bbox("all"))

        inner_frame.bind("<Configure>", configure_scrollregion)

        # Превью текущей модели
        current_preview_frame = ttk.LabelFrame(
            inner_frame, text=tr('editor_preview'))
        current_preview_frame.pack(fill="x", pady=(0, 10), padx=5)

        current_preview_label = ttk.Label(current_preview_frame)
        current_preview_label.pack(padx=5, pady=5)

        try:
            if self.model_dir:
                preview_path = os.path.join(self.model_dir, "preview.png")
                if os.path.exists(preview_path):
                    img = Image.open(preview_path)
                    img.thumbnail((120, 120), Image.LANCZOS)
                    current_preview_img = ImageTk.PhotoImage(img)
                    slot_dialog.images.append(current_preview_img)
                    current_preview_label.configure(image=current_preview_img)
                else:
                    img = Image.new("RGBA", (120, 120), (0, 0, 0, 0))
                    current_preview_img = ImageTk.PhotoImage(img)
                    slot_dialog.images.append(current_preview_img)
                    current_preview_label.configure(image=current_preview_img)
        except Exception as e:
            logger.error(f"Error loading current preview: {e}")

        ttk.Label(current_preview_frame,
                  text=f"{tr('editor_model_name')}: {self.model_name_var.get()}",
                  font=("Arial", 9)).pack()

        # Слоты
        slots_frame = ttk.Frame(inner_frame)
        slots_frame.pack(fill="both", expand=True, padx=5, pady=5)

        for i in range(1, 7):
            slot_frame = ttk.LabelFrame(slots_frame, text=f"{tr('slot')} {i}")
            slot_frame.pack(fill="x", pady=5, padx=5)

            content_frame = ttk.Frame(slot_frame)
            content_frame.pack(fill="x", padx=5, pady=5)

            # Превью слота
            try:
                preview_path = os.path.join(
                    MODELS_DIR, f"slot{i}", "preview.png")
                if os.path.exists(preview_path):
                    img = Image.open(preview_path)
                    img.thumbnail((80, 80), Image.LANCZOS)
                    preview_img = ImageTk.PhotoImage(img)
                    slot_dialog.images.append(preview_img)

                    preview_label = ttk.Label(content_frame, image=preview_img)
                    preview_label.pack(side="left", padx=5, pady=5)
                else:
                    img = Image.new("RGBA", (80, 80), (0, 0, 0, 0))
                    preview_img = ImageTk.PhotoImage(img)
                    slot_dialog.images.append(preview_img)

                    preview_label = ttk.Label(content_frame, image=preview_img)
                    preview_label.pack(side="left", padx=5, pady=5)
            except Exception as e:
                logger.error(f"Error loading preview for slot {i}: {e}")

            # Информация о слоте
            info_frame = ttk.Frame(content_frame)
            info_frame.pack(side="left", fill="both", expand=True, padx=5)

            slot_dir = os.path.join(MODELS_DIR, f"slot{i}")
            json_path = os.path.join(slot_dir, "model.json")

            if os.path.exists(json_path):
                try:
                    with open(json_path, "r", encoding="utf-8") as f:
                        model_data = json.load(f)
                    model_name = model_data.get('name', f"{tr('slot')} {i}")
                    status_text = f"Занят: {model_name}"
                    btn_text = tr('editor_save')
                except:
                    status_text = tr('error')
                    btn_text = tr('editor_save')
            else:
                status_text = tr('empty_slot')
                btn_text = tr('editor_save')

            status = ttk.Label(info_frame, text=status_text, font=("Arial", 8))
            status.pack(anchor="w", pady=(5, 0))

            btn = ttk.Button(
                info_frame,
                text=btn_text,
                command=lambda slot=i, dlg=slot_dialog: self._save_slot(
                    slot, dlg)
            )
            btn.pack(anchor="w", pady=5)

        ttk.Button(slot_dialog, text=tr('port_dialog_cancel'),
                   command=slot_dialog.destroy).pack(pady=10)

        slot_dialog.update()

    def _save_slot(self, slot_num, dialog):
        dialog.destroy()

        slot_dir = os.path.join(MODELS_DIR, f"slot{slot_num}")
        os.makedirs(slot_dir, exist_ok=True)

        try:
            # Очищаем слот
            for f in os.listdir(slot_dir):
                file_path = os.path.join(slot_dir, f)
                try:
                    if os.path.isfile(file_path):
                        os.unlink(file_path)
                except Exception as e:
                    logger.error(f"Error deleting file {file_path}: {e}")

            # Копируем файлы
            for f in os.listdir(self.model_dir):
                src = os.path.join(self.model_dir, f)
                if os.path.isfile(src):
                    shutil.copy2(src, os.path.join(slot_dir, f))

            self.original_slot = slot_num

            messagebox.showinfo(
                tr('model_saved'), tr('model_saved_msg', slot=slot_num))

            if self.on_save:
                self.on_save(self.model, slot_dir, slot_num)

            if hasattr(self.master, 'app') and hasattr(self.master.app, 'refresh_slot_buttons'):
                self.master.app.refresh_slot_buttons()

            logger.info(f"Model saved to slot {slot_num}")

        except Exception as e:
            logger.error(f"Error saving to slot {slot_num}: {e}")
            messagebox.showerror(
                tr('error'), f"Не удалось сохранить модель в слот {slot_num}: {e}")

    def create_preview(self):
        """Создает превью модели"""
        if not self.model_dir:
            return

        try:
            base = Image.new("RGBA", (self.canvas_width,
                             self.canvas_height), (0, 0, 0, 0))
            center_x = self.canvas_width // 2
            center_y = self.canvas_height // 2

            visible_items = [ci for ci in self.items if ci.visible]

            for ci in visible_items:
                # Загружаем оригинальное изображение (как в рендерере)
                try:
                    img = Image.open(ci.image_path).convert("RGBA")

                    # ПРАВИЛЬНЫЙ ПОРЯДОК ТРАНСФОРМАЦИЙ (такой же как в редакторе):
                    # 1. Масштаб элемента
                    if ci.scale != 1.0:
                        new_width = max(1, int(img.width * ci.scale))
                        new_height = max(1, int(img.height * ci.scale))
                        img = img.resize(
                            (new_width, new_height), Image.LANCZOS)

                    # 2. Отражение
                    if ci.flip_horizontal:
                        img = img.transpose(Image.FLIP_LEFT_RIGHT)
                    if ci.flip_vertical:
                        img = img.transpose(Image.FLIP_TOP_BOTTOM)

                    # 3. Поворот
                    if ci.rotation != 0:
                        img = img.rotate(
                            ci.rotation, expand=True, resample=Image.BICUBIC)

                    # 4. Применяем прозрачность
                    if ci.alpha < 1.0:
                        if img.mode == 'RGBA':
                            r, g, b, a = img.split()
                            a = a.point(lambda x: int(x * ci.alpha))
                            img = Image.merge('RGBA', (r, g, b, a))

                    # Рассчитываем позицию
                    px = center_x - img.size[0] // 2 + int(ci.x)
                    py = center_y - img.size[1] // 2 + int(ci.y)

                    base.alpha_composite(img, (px, py))
                except Exception as e:
                    logger.error(f"Error creating preview: {e}")

            # Уменьшаем для превью
            base.thumbnail((200, 200), Image.LANCZOS)
            preview_path = os.path.join(self.model_dir, "preview.png")
            base.save(preview_path)

        except Exception as e:
            logger.error(f"Error creating preview: {e}")

    def import_images(self):
        """Импортирует изображения"""
        files = filedialog.askopenfilenames(
            title=tr('editor_import'),
            filetypes=[("Изображения", "*.png *.gif"), ("Все файлы", "*.*")]
        )
        if not files:
            return

        if not self.model_dir:
            tmp = os.path.join(MODELS_DIR, f"model_temp_{int(time.time())}")
            os.makedirs(tmp, exist_ok=True)
            self.model_dir = tmp

            self.cleanup_old_temp_folders()

        for file_path in files:
            try:
                base = os.path.basename(file_path)
                dest = os.path.join(self.model_dir, base)

                # Если файл уже существует, создаем уникальное имя
                if os.path.exists(dest):
                    name, ext = os.path.splitext(base)
                    counter = 1
                    while True:
                        new_base = f"{name}({counter}){ext}"
                        new_dest = os.path.join(self.model_dir, new_base)
                        if not os.path.exists(new_dest):
                            base = new_base
                            dest = new_dest
                            break
                        counter += 1

                if os.path.abspath(file_path) != os.path.abspath(dest):
                    shutil.copy2(file_path, dest)

                # Определяем тип изображения
                is_gif = False
                if base.lower().endswith('.gif'):
                    with Image.open(file_path) as img:
                        is_gif = img.is_animated

                # Создаем превью для списка
                with Image.open(file_path) as img:
                    img.seek(0)
                    preview_img = img.copy().convert("RGBA")
                    preview_img.thumbnail((50, 50), Image.LANCZOS)

                self.imported_files.append((base, preview_img, is_gif))

                # Генерируем уникальное имя для слоя
                base_name = os.path.splitext(base)[0]
                layer_name = base_name
                counter = 1

                # Проверяем, существует ли уже слой с таким именем
                existing_names = {layer.get("name")
                                  for layer in self.model.get("layers", [])}
                while layer_name in existing_names:
                    layer_name = f"{base_name}({counter})"
                    counter += 1

                # Создаем слой
                layer = {
                    "name": layer_name,  # Используем уникальное имя
                    "file": base,
                    "visible": True,
                    "x": 0,
                    "y": 0,
                    "scale": 1.0,
                    "rotation": 0,
                    "alpha": 1.0,
                    "group": None,
                    "is_gif": is_gif,
                    "flip_horizontal": False,
                    "flip_vertical": False
                }
                self.model.setdefault("layers", []).append(layer)

                # Создаем элемент
                ci = CanvasItem(layer, dest)
                self.items.append(ci)

            except Exception as e:
                logger.error(f"Error importing image {file_path}: {e}")

        self.refresh_import_list()

        self._save_tree_state()
        self.tree_state["preserve_selection"] = True

        self.refresh_tree()
        self._canvas_cache_valid = False
        self.redraw_canvas()
        self.last_autosave = time.time()

        logger.info(tr('imported_images', count=len(files)))
        self.save_to_history(tr('imported_images', count=len(files)))

    def refresh_import_list(self):
        """Обновляет список импортированных файлов"""
        for w in self.import_inner.winfo_children():
            w.destroy()

        for fname, img, is_gif in self.imported_files:
            row = ttk.Frame(self.import_inner)
            row.pack(fill="x", padx=2, pady=2)

            # Показываем превью изображения
            try:
                photo = ImageTk.PhotoImage(img)
                preview_label = ttk.Label(row, image=photo)
                preview_label.image = photo  # Сохраняем ссылку
                preview_label.pack(side="left", padx=2)
            except:
                pass

            icon = "GIF" if is_gif else "PNG"
            ttk.Label(row, text=f"{icon}: {fname}",
                      width=20).pack(side="left", padx=2)

            # Кнопка добавления на холст (теперь будет создавать новый слой с уникальным именем)
            ttk.Button(row, text="+", width=2,
                       command=lambda f=fname: self.add_to_canvas(f)).pack(side="left", padx=2)
            ttk.Button(row, text="🗑️", width=2, command=lambda f=fname: self.delete_file(
                f)).pack(side="left", padx=2)

    def clear_props_fields(self):
        """Очищает поля свойств"""
        self.name_entry.delete(0, "end")
        self.x_entry.delete(0, "end")
        self.y_entry.delete(0, "end")
        self.scale_entry.delete(0, "end")
        self.rotation_entry.delete(0, "end")
        self.alpha_entry.delete(0, "end")
        self.flip_h_var.set(False)
        self.flip_v_var.set(False)
        self.visible_var.set(True)

    def load_item_props(self, ci):
        """Загружает свойства элемента в поля"""
        try:
            self.name_entry.delete(0, "end")
            self.name_entry.insert(0, ci.layer.get("name", ""))

            self.x_entry.delete(0, "end")
            self.x_entry.insert(0, str(ci.x))

            self.y_entry.delete(0, "end")
            self.y_entry.insert(0, str(ci.y))

            self.scale_entry.delete(0, "end")
            self.scale_entry.insert(0, str(ci.scale))

            self.rotation_entry.delete(0, "end")
            self.rotation_entry.insert(0, str(ci.rotation))

            self.alpha_entry.delete(0, "end")
            self.alpha_entry.insert(0, str(ci.alpha))

            self.flip_h_var.set(bool(ci.flip_horizontal))
            self.flip_v_var.set(bool(ci.flip_vertical))
            self.visible_var.set(bool(ci.visible))
        except Exception as e:
            logger.error(f"Error loading item properties: {e}")

    def apply_props_from_entry(self, event=None):
        """Применяет свойства из полей ввода"""
        self.apply_props()

    def apply_props(self):
        """Применяет свойства к выбранным элементам"""
        if not self.current_selection:
            messagebox.showwarning(tr('warning'), tr('editor_apply_props'))
            return

        # Сохраняем предыдущее состояние перед изменением
        self.save_to_history(tr('editor_item_props'))

        for ci in self.current_selection:
            # Имя
            name = self.name_entry.get().strip()
            if name:
                ci.layer["name"] = name

            # Координаты
            try:
                ci.x = int(self.x_entry.get().strip())
                ci.y = int(self.y_entry.get().strip())
            except ValueError:
                messagebox.showwarning(
                    tr('warning'), tr('editor_x') + " и " + tr('editor_y') + " должны быть целыми числами")
                return

            # Масштаб и поворот
            try:
                ci.scale = float(self.scale_entry.get().strip())
                ci.rotation = int(self.rotation_entry.get().strip())
            except ValueError:
                messagebox.showwarning(
                    tr('warning'), tr('editor_scale') + " должен быть дробным числом, " + tr('editor_rotation') + " - целым")
                return

            # Прозрачность
            try:
                alpha = float(self.alpha_entry.get().strip())
                if alpha < 0.0 or alpha > 1.0:
                    messagebox.showwarning(
                        tr('warning'), tr('editor_alpha') + " должна быть от 0.0 до 1.0")
                    return
                ci.alpha = alpha
            except ValueError:
                messagebox.showwarning(
                    tr('warning'), tr('editor_alpha') + " должна быть числом")
                return

            # Видимость и отражение
            ci.visible = self.visible_var.get()
            ci.flip_horizontal = self.flip_h_var.get()
            ci.flip_vertical = self.flip_v_var.get()

            # Очищаем кэш изображения
            ci.clear_cache()

        # Очищаем кэш редактора
        self._photo_images.clear()
        self._canvas_cache_valid = False

        self._save_tree_state()
        self.tree_state["preserve_selection"] = True

        self.refresh_tree()
        self.redraw_canvas()
        self.last_autosave = time.time()

        self.save_to_history(tr('editor_item_props'))

    def load_group_settings(self, group_name):
        """Загружает настройки группы"""
        group = next((g for g in self.model.get("groups", [])
                      if g.get("name") == group_name), None)
        if not group:
            return

        # Сначала обновляем меню
        self.update_group_logic_menus(group_name)

        # Затем загружаем значения
        logic = group.get("logic", {})

        # Загружаем состояния рта
        for i, state in enumerate(self.mouth_states):
            state_key = f"state_{i}"
            if state_key in logic and state_key in self.state_vars:
                self.state_vars[state_key].set(logic[state_key])
            else:
                if state_key in self.state_vars:
                    self.state_vars[state_key].set("")

        # Загружаем blink и open
        if "blink" in logic:
            self.blink_var.set(logic["blink"])
        else:
            self.blink_var.set("")

        if "open" in logic:
            self.open_var.set(logic["open"])
        else:
            self.open_var.set("")

        # Настройки моргания
        blink_freq = group.get("blink_freq", 0.0)
        self.blink_freq.set(blink_freq)

        # Случайный эффект
        self.random_effect_var.set(group.get("random_effect", False))
        self.random_min_var.set(group.get("random_min", 5.0))
        self.random_max_var.set(group.get("random_max", 10.0))

    def ungroup_selected(self):
        """Разгруппировывает выделенные элементы"""
        if not self.selected_group and not self.current_selection:
            return

        if self.selected_group:
            group_name = self.selected_group

            # Получаем группу
            group = next((g for g in self.model.get("groups", [])
                          if g.get("name") == group_name), None)
            if not group:
                return

            parent_group = group.get("parent")

            # Если есть родительская группа, переносим элементы в нее
            if parent_group:
                parent = next((g for g in self.model.get(
                    "groups", []) if g.get("name") == parent_group), None)
                if parent:
                    # Переносим элементы в родительскую группу
                    for ci in self.items:
                        if ci.layer.get("group") == group_name:
                            ci.layer["group"] = parent_group
                            if ci.layer.get("name") not in parent.get("children", []):
                                parent.setdefault("children", []).append(
                                    ci.layer.get("name"))
                    # Удаляем ссылку на группу из родительской группы
                    if group_name in parent.get("children", []):
                        parent["children"].remove(group_name)
            else:
                # Если нет родительской группы, удаляем группу у элементов
                for ci in self.items:
                    if ci.layer.get("group") == group_name:
                        ci.layer["group"] = None

            # Удаляем группу
            self.model["groups"] = [g for g in self.model.get(
                "groups", []) if g.get("name") != group_name]

            # Удаляем все дочерние группы этой группы
            child_groups = [g for g in self.model.get(
                "groups", []) if g.get("parent") == group_name]
            for child_group in child_groups:
                # Рекурсивно удаляем дочерние группы
                self._delete_group_and_children(child_group.get("name"))

            self.selected_group = parent_group

            # Сохраняем состояние дерева
            self._save_tree_state()
            self.tree_state["preserve_selection"] = True

            self.refresh_tree()
            self._canvas_cache_valid = False
            self.redraw_canvas()
            logger.info(tr('group_deleted', name=group_name))
            self.save_to_history(tr('editor_ungroup'))
            return

        if not self.current_selection:
            return

        # Разгруппирование отдельных элементов
        for ci in self.current_selection:
            grp = ci.layer.get("group")
            if grp:
                for g in list(self.model.get("groups", [])):
                    if g.get("name") == grp and ci.layer.get("name") in g.get("children", []):
                        g["children"].remove(ci.layer.get("name"))
                        if not g["children"]:
                            # Если группа пуста, удаляем ее
                            self.model["groups"].remove(g)
                ci.layer["group"] = None

        # Сохраняем состояние дерева
        self._save_tree_state()
        self.tree_state["preserve_selection"] = True

        self.refresh_tree()
        self._canvas_cache_valid = False
        self.redraw_canvas()
        logger.info(f"Ungrouped {len(self.current_selection)} items")
        self.save_to_history(tr('editor_ungroup'))

    def _delete_group_and_children(self, group_name):
        """Рекурсивно удаляет группу и все ее дочерние группы"""
        # Удаляем группу у элементов
        for ci in self.items:
            if ci.layer.get("group") == group_name:
                ci.layer["group"] = None

        # Удаляем дочерние группы
        child_groups = [g for g in self.model.get(
            "groups", []) if g.get("parent") == group_name]
        for child_group in child_groups:
            self._delete_group_and_children(child_group.get("name"))

        # Удаляем саму группу
        self.model["groups"] = [g for g in self.model.get(
            "groups", []) if g.get("name") != group_name]

    def on_canvas_mouse_down(self, event):
        """Обработчик нажатия мыши на холсте с учетом групп"""
        focus_widget = self.focus_get()
        if isinstance(focus_widget, (ttk.Entry, tk.Entry, ttk.Combobox)):
            return

        # Преобразуем координаты мыши в координаты холста с учетом зума
        canvas_width = self.canvas.winfo_width()
        canvas_height = self.canvas.winfo_height()
        scaled_width = int(self.canvas_width * self.zoom_level)
        scaled_height = int(self.canvas_height * self.zoom_level)

        center_x = canvas_width // 2 + self.offset_x
        center_y = canvas_height // 2 + self.offset_y

        canvas_x1 = center_x - scaled_width // 2
        canvas_y1 = center_y - scaled_height // 2

        # Координаты относительно холста с учетом зума
        mx = (event.x - canvas_x1) / \
            self.zoom_level if self.zoom_level > 0 else 0
        my = (event.y - canvas_y1) / \
            self.zoom_level if self.zoom_level > 0 else 0

        # Сохраняем стартовые координаты для корректного Undo
        self.drag_data = {"item": None, "x": mx, "y": my,
                          "start_x": mx, "start_y": my, "group_items": []}

        found_items = []
        # Ищем элемент под курсором (с конца для правильного Z-порядка)
        for ci in reversed(self.items):
            if not ci.visible:
                continue

            img = ci.get_image_for_display(self.zoom_level)
            if img is None:
                continue

            # Позиция элемента
            center_x_scaled = scaled_width // 2
            center_y_scaled = scaled_height // 2

            offset_x = int(ci.x * self.zoom_level)
            offset_y = int(ci.y * self.zoom_level)

            pos_x = canvas_x1 + center_x_scaled - img.width // 2 + offset_x
            pos_y = canvas_y1 + center_y_scaled - img.height // 2 + offset_y

            # Проверяем попадание
            if (pos_x <= event.x <= pos_x + img.width and
                    pos_y <= event.y <= pos_y + img.height):

                # Проверяем прозрачность пикселя
                try:
                    is_opaque = False
                    if img.mode == 'RGBA':
                        pixel_x = int(event.x - pos_x)
                        pixel_y = int(event.y - pos_y)

                        if 0 <= pixel_x < img.width and 0 <= pixel_y < img.height:
                            pixel = img.getpixel((pixel_x, pixel_y))
                            # Порог прозрачности
                            if len(pixel) >= 4 and pixel[3] > 10:
                                is_opaque = True
                    else:
                        # Для непрозрачных форматов всегда считаем непрозрачным
                        is_opaque = True

                    if is_opaque:
                        found_items.append(ci)  # Добавляем в список

                except Exception as e:
                    logger.error(f"Error checking pixel: {e}")
                    found_items.append(ci)  # В случае ошибки тоже добавляем

        if found_items:
            found = found_items[0]  # Берем первый (самый верхний) элемент
            group_name = found.layer.get("group")

            # Если кликнутый объект уже выделен (например, потому что в дереве выбрана вся группа)
            if found in self.current_selection:
                # Просто начинаем перетаскивание текущего выделения
                self.drag_data["item"] = found
                self.drag_data["group_items"] = self.current_selection.copy()

                # Если выделен только один объект, загружаем его свойства
                if len(self.current_selection) == 1:
                    self._select_item_in_tree(found)
                    self.load_item_props(found)
                    self.selected_group = None
                    self.group_label.config(
                        text=found.layer.get("group") or tr('editor_no_group'))
            else:
                # Объект не был выделен. Работает как обычный клик.
                if event.state & 0x0004:  # Ctrl
                    found.layer["_selected"] = True
                    if found not in self.current_selection:
                        self.current_selection.append(found)
                else:
                    # Сбрасываем выделение на холсте
                    for ci in self.items:
                        ci.layer["_selected"] = False

                    # Если элемент в группе, выделяем всю группу (рекурсивно)
                    if group_name:
                        self.selected_group = group_name
                        self.current_selection = self._get_all_items_in_group_recursive(
                            group_name)
                        for ci in self.current_selection:
                            ci.layer["_selected"] = True
                        self._select_group_in_tree(group_name)
                        self.group_label.config(text=group_name)
                        self.load_group_settings(group_name)
                    else:
                        found.layer["_selected"] = True
                        self.current_selection = [found]
                        self.selected_group = None
                        self.group_label.config(text=tr('editor_no_group'))
                        self._select_item_in_tree(found)
                        self.load_item_props(found)

                self.drag_data["item"] = found
                self.drag_data["group_items"] = self.current_selection.copy()

        else:
            # Клик по пустому месту
            for ci in self.items:
                ci.layer["_selected"] = False
            self.current_selection = []
            self.selected_group = None
            self.group_label.config(text=tr('editor_no_group'))
            self.clear_props_fields()
            self.tree.selection_remove(self.tree.selection())

        self._canvas_cache_valid = False
        self.redraw_canvas()

    def on_canvas_mouse_move(self, event):
        """Обработчик перемещения мыши с зажатой кнопкой"""
        if not self.drag_data.get("item") or not self.drag_data.get("group_items"):
            return

        # Преобразуем координаты
        canvas_width = self.canvas.winfo_width()
        canvas_height = self.canvas.winfo_height()
        scaled_width = int(self.canvas_width * self.zoom_level)
        scaled_height = int(self.canvas_height * self.zoom_level)

        center_x = canvas_width // 2 + self.offset_x
        center_y = canvas_height // 2 + self.offset_y

        canvas_x1 = center_x - scaled_width // 2
        canvas_y1 = center_y - scaled_height // 2

        mx = (event.x - canvas_x1) / \
            self.zoom_level if self.zoom_level > 0 else 0
        my = (event.y - canvas_y1) / \
            self.zoom_level if self.zoom_level > 0 else 0

        dx = mx - self.drag_data["x"]
        dy = my - self.drag_data["y"]

        self.drag_data["x"] = mx
        self.drag_data["y"] = my

        # Перемещаем элементы
        for ci in self.drag_data["group_items"]:
            ci.x += int(dx)
            ci.y += int(dy)

        # Обновляем поля ввода
        if len(self.drag_data["group_items"]) == 1:
            self.x_entry.delete(0, "end")
            self.x_entry.insert(0, str(self.drag_data["group_items"][0].x))
            self.y_entry.delete(0, "end")
            self.y_entry.insert(0, str(self.drag_data["group_items"][0].y))

        self._canvas_cache_valid = False
        self.redraw_canvas()

    def on_canvas_mouse_up(self, event):
        """Обработчик отпускания кнопки мыши"""
        if self.drag_data.get("item"):
            # Проверяем, было ли реальное перемещение (сравниваем старт и текущую позицию)
            if abs(self.drag_data.get("start_x", 0) - self.drag_data.get("x", 0)) > 0.1 or \
               abs(self.drag_data.get("start_y", 0) - self.drag_data.get("y", 0)) > 0.1:
                self.save_to_history(tr('editor_x') + "/" + tr('editor_y'))

        self.drag_data["item"] = None
        self.drag_data["group_items"] = []

    def add_to_canvas(self, filename):
        """Добавляет файл на холст с уникальным именем"""
        for fname, img, is_gif in self.imported_files:
            if fname == filename:
                # Генерируем уникальное имя для нового слоя
                base_name = os.path.splitext(fname)[0]
                layer_name = base_name
                counter = 1

                # Проверяем существующие имена слоев
                existing_names = {layer.get("name")
                                  for layer in self.model.get("layers", [])}
                while layer_name in existing_names:
                    layer_name = f"{base_name}({counter})"
                    counter += 1

                # Создаем новый слой с уникальным именем
                layer = {
                    "name": layer_name,  # Уникальное имя
                    "file": fname,
                    "visible": True,
                    "x": 0,
                    "y": 0,
                    "scale": 1.0,
                    "rotation": 0,
                    "alpha": 1.0,
                    "group": None,
                    "is_gif": is_gif,
                    "flip_horizontal": False,
                    "flip_vertical": False
                }
                self.model.setdefault("layers", []).append(layer)

                # Создаем элемент
                image_path = os.path.join(self.model_dir, fname)
                ci = CanvasItem(layer, image_path)
                self.items.append(ci)

                self._save_tree_state()
                self.tree_state["preserve_selection"] = True

                self.refresh_tree()
                self._canvas_cache_valid = False
                self.redraw_canvas()
                return

    def remove_from_canvas_by_file(self, filename):
        """Удаляет файл с холста"""
        new_items = [ci for ci in self.items if ci.layer.get(
            "file") != filename]
        if len(new_items) != len(self.items):
            self.items = new_items

            # Удаляем выделение
            for l in self.model.get("layers", []):
                if l.get("file") == filename:
                    l["_selected"] = False

            self._save_tree_state()
            self.tree_state["preserve_selection"] = True

            self.refresh_tree()
            self._canvas_cache_valid = False
            self.redraw_canvas()

    def delete_file(self, filename):
        """Удаляет файл полностью"""
        if messagebox.askyesno(tr('delete_confirm_title'), f"Удалить {filename} навсегда?"):
            self.remove_from_canvas_by_file(filename)
            self.imported_files = [
                f for f in self.imported_files if f[0] != filename]

            if self.model_dir:
                file_path = os.path.join(self.model_dir, filename)
                if os.path.exists(file_path):
                    os.remove(file_path)

            self.model["layers"] = [
                l for l in self.model["layers"] if l.get("file") != filename]
            self.refresh_import_list()

            self._save_tree_state()
            self.tree_state["preserve_selection"] = True

            self.refresh_tree()
            self._canvas_cache_valid = False
            self.redraw_canvas()

            logger.info(f"File deleted: {filename}")
            self.save_to_history(tr('editor_delete_model'))

    def show_blink_preview(self):
        """Показывает превью моргания"""
        if not self.selected_group:
            return

        self.blink_preview_running = True
        self._blink_preview_loop()
        logger.info("Blink preview started")

    def stop_blink_preview(self):
        """Останавливает превью моргания"""
        self.blink_preview_running = False
        logger.info("Blink preview stopped")

    def _blink_preview_loop(self):
        if not self.blink_preview_running:
            return

        gname = self.selected_group
        group = next((g for g in self.model.get("groups", [])
                      if g.get("name") == gname), None)
        if not group:
            return

        blink_freq = float(group.get("blink_freq", 0.0))
        if blink_freq < 0.1:
            return

        logic = group.get("logic", {})
        blink_layer = logic.get("blink", "")

        # Скрываем все элементы в группе
        for ci in self.items:
            if ci.layer.get("group") == gname:
                # Показываем только слой для моргания
                ci.visible = (ci.layer.get("name") == blink_layer)

        self.redraw_canvas(0, "none")
        self.after(200, self._show_normal_preview)

    def _show_normal_preview(self):
        if not self.blink_preview_running:
            return

        gname = self.selected_group
        group = next((g for g in self.model.get("groups", [])
                      if g.get("name") == gname), None)
        if not group:
            return

        logic = group.get("logic", {})
        open_layer = logic.get("open") or logic.get(
            "normal") or logic.get("whisper") or logic.get("silent")

        # Скрываем все элементы в группе
        for ci in self.items:
            if ci.layer.get("group") == gname:
                # Показываем только основной слой
                ci.visible = (ci.layer.get("name") == open_layer)

        self.redraw_canvas(0, "none")

        blink_freq = float(group.get("blink_freq", 0.0))
        if blink_freq > 0.1:
            self.after(int(blink_freq * 1000), self._blink_preview_loop)

    def _preview_loop(self):
        """Основной цикл предпросмотра"""
        try:
            # Автосохранение
            now = time.time()
            if now - self.last_autosave > self.autosave_interval:
                try:
                    if self.model_dir:
                        temp = {
                            "name": self.model.get("name", ""),
                            "width": self.model.get("width", 700),
                            "height": self.model.get("height", 700),
                            "layers": [],
                            "groups": self.model.get("groups", []),
                            "mouth_states": self.mouth_states  # Сохраняем состояния рта
                        }
                        for ci in self.items:
                            temp["layers"].append({
                                "name": ci.layer.get("name"),
                                "file": os.path.basename(ci.layer.get("file")),
                                "x": int(ci.x),
                                "y": int(ci.y),
                                "visible": bool(ci.visible),
                                "is_gif": ci.is_gif,
                                "scale": float(ci.scale),
                                "rotation": int(ci.rotation),
                                "alpha": float(ci.alpha),
                                "group": ci.layer.get("group", None),
                                "flip_horizontal": bool(ci.flip_horizontal),
                                "flip_vertical": bool(ci.flip_vertical),
                                "uuid": ci.uuid  # Сохраняем UUID
                            })
                        with open(os.path.join(self.model_dir, "model.json"), "w", encoding="utf-8") as f:
                            json.dump(temp, f, indent=2, ensure_ascii=False)
                except Exception as e:
                    logger.error(f"Error autosaving: {e}")
                self.last_autosave = now

            # Обновляем отображение в зависимости от режима
            mode = self.test_mode_var.get()
            level = self.audio_level if mode == "microphone" else 0.0

            self.redraw_canvas(level, mode)

        except Exception as e:
            logger.error(f"Error in preview loop: {e}")
        finally:
            if self.winfo_exists():
                self.after(int(1000 / self.preview_fps), self._preview_loop)