public class FileSystemItem : INotifyPropertyChanged
{
    private bool _isExpanded;
    
    public string Name { get; set; }
    public FileSystemItemType Type { get; set; }
    public ObservableCollection<FileSystemItem> Children { get; set; }
    
    public bool IsExpanded
    {
        get => _isExpanded;
        set
        {
            _isExpanded = value;
            OnPropertyChanged();
        }
    }
    
    public string Icon => Type switch
    {
        FileSystemItemType.Folder => "📁",
        FileSystemItemType.Document => "📄",
        FileSystemItemType.Image => "🖼️",
        FileSystemItemType.Audio => "🎵",
        FileSystemItemType.Video => "🎬",
        _ => "📄"
    };
    
    public FileSystemItem()
    {
        Children = new ObservableCollection<FileSystemItem>();
    }
    
    public event PropertyChangedEventHandler PropertyChanged;
    protected void OnPropertyChanged([CallerMemberName] string name = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(name));
    }
}

public enum FileSystemItemType
{
    Folder,
    Document,
    Image,
    Audio,
    Video
}

public class FileExplorerViewModel : INotifyPropertyChanged
{
    public ObservableCollection<FileSystemItem> RootItems { get; set; }
    
    public FileExplorerViewModel()
    {
        RootItems = new ObservableCollection<FileSystemItem>
        {
            new FileSystemItem
            {
                Name = "Документи",
                Type = FileSystemItemType.Folder,
                IsExpanded = true,
                Children = new ObservableCollection<FileSystemItem>
                {
                    new FileSystemItem { Name = "Звіт.docx", Type = FileSystemItemType.Document },
                    new FileSystemItem { Name = "Презентація.pptx", Type = FileSystemItemType.Document },
                    new FileSystemItem
                    {
                        Name = "Архів",
                        Type = FileSystemItemType.Folder,
                        Children = new ObservableCollection<FileSystemItem>
                        {
                            new FileSystemItem { Name = "Старий_звіт.docx", Type = FileSystemItemType.Document }
                        }
                    }
                }
            },
            new FileSystemItem
            {
                Name = "Зображення",
                Type = FileSystemItemType.Folder,
                Children = new ObservableCollection<FileSystemItem>
                {
                    new FileSystemItem { Name = "Фото1.jpg", Type = FileSystemItemType.Image },
                    new FileSystemItem { Name = "Фото2.png", Type = FileSystemItemType.Image }
                }
            }
        };
    }
    
    public event PropertyChangedEventHandler PropertyChanged;
}

<TreeView.ItemContainerStyle>
    <Style Selector="TreeViewItem">
        <!-- TwoWay binding для синхронізації з ViewModel -->
        <Setter Property="IsExpanded" Value="{Binding IsExpanded, Mode=TwoWay}" />
    </Style>
</TreeView.ItemContainerStyle>

// Розгорнути всі вузли
public void ExpandAll(FileSystemItem item)
{
    item.IsExpanded = true;
    foreach (var child in item.Children)
    {
        ExpandAll(child);
    }
}

// Згорнути всі вузли
public void CollapseAll(FileSystemItem item)
{
    item.IsExpanded = false;
    foreach (var child in item.Children)
    {
        CollapseAll(child);
    }
}

public class FileSystemItem : INotifyPropertyChanged
{
    private bool _isExpanded;
    private bool _childrenLoaded;
    
    public bool IsExpanded
    {
        get => _isExpanded;
        set
        {
            _isExpanded = value;
            OnPropertyChanged();
            
            // Завантажити дочірні елементи при першому розгортанні
            if (value && !_childrenLoaded && Type == FileSystemItemType.Folder)
            {
                LoadChildren();
            }
        }
    }
    
    private void LoadChildren()
    {
        _childrenLoaded = true;
        
        // Видалити placeholder
        Children.Clear();
        
        // Завантажити реальні дочірні елементи
        try
        {
            var directoryInfo = new DirectoryInfo(FullPath);
            
            foreach (var dir in directoryInfo.GetDirectories())
            {
                Children.Add(new FileSystemItem
                {
                    Name = dir.Name,
                    FullPath = dir.FullName,
                    Type = FileSystemItemType.Folder,
                    Children = new ObservableCollection<FileSystemItem>
                    {
                        // Placeholder для показу стрілки розгортання
                        new FileSystemItem { Name = "Loading..." }
                    }
                });
            }
            
            foreach (var file in directoryInfo.GetFiles())
            {
                Children.Add(new FileSystemItem
                {
                    Name = file.Name,
                    FullPath = file.FullName,
                    Type = GetFileType(file.Extension)
                });
            }
        }
        catch (UnauthorizedAccessException)
        {
            // Немає доступу до папки
            Children.Add(new FileSystemItem { Name = "Access Denied" });
        }
    }
    
    private FileSystemItemType GetFileType(string extension)
    {
        return extension.ToLower() switch
        {
            ".jpg" or ".png" or ".gif" => FileSystemItemType.Image,
            ".mp3" or ".wav" => FileSystemItemType.Audio,
            ".mp4" or ".avi" => FileSystemItemType.Video,
            _ => FileSystemItemType.Document
        };
    }
}

<TreeView ItemsSource="{Binding RootItems}"
          SelectedItem="{Binding SelectedItem, Mode=TwoWay}">
    <!-- ItemTemplate -->
</TreeView>

public class FileExplorerViewModel : INotifyPropertyChanged
{
    private FileSystemItem _selectedItem;
    
    public FileSystemItem SelectedItem
    {
        get => _selectedItem;
        set
        {
            _selectedItem = value;
            OnPropertyChanged();
            
            // Реакція на зміну виділення
            if (value != null)
            {
                Debug.WriteLine($"Виділено: {value.Name}");
                LoadDetails(value);
            }
        }
    }
    
    private void LoadDetails(FileSystemItem item)
    {
        // Завантажити деталі про файл/папку
        // Показати у панелі деталей
    }
}

public partial class MainWindow : Window
{
    public MainWindow()
    {
        InitializeComponent();
        
        var sourceListBox = this.FindControl<ListBox>("SourceListBox");
        var targetListBox = this.FindControl<ListBox>("TargetListBox");
        
        // Налаштування джерела (звідки перетягуємо)
        sourceListBox.PointerPressed += (s, e) =>
        {
            if (e.GetCurrentPoint(sourceListBox).Properties.IsLeftButtonPressed)
            {
                var item = sourceListBox.SelectedItem;
                if (item != null)
                {
                    var data = new DataObject();
                    data.Set("TaskItem", item);
                    DragDrop.DoDragDrop(e, data, DragDropEffects.Move);
                }
            }
        };
        
        // Налаштування цілі (куди перетягуємо)
        targetListBox.AddHandler(DragDrop.DropEvent, (s, e) =>
        {
            var data = e.Data.Get("TaskItem");
            if (data != null)
            {
                // Видалити з джерела
                var sourceItems = (ObservableCollection<string>)sourceListBox.ItemsSource;
                sourceItems.Remove(data.ToString());
                
                // Додати до цілі
                var targetItems = (ObservableCollection<string>)targetListBox.ItemsSource;
                targetItems.Add(data.ToString());
            }
        });
        
        targetListBox.AddHandler(DragDrop.DragOverEvent, (s, e) =>
        {
            // Дозволити drop
            e.DragEffects = DragDropEffects.Move;
        });
    }
}

public class DragDropBehavior
{
    public static readonly DependencyProperty IsDragSourceProperty =
        DependencyProperty.RegisterAttached(
            "IsDragSource",
            typeof(bool),
            typeof(DragDropBehavior),
            new PropertyMetadata(false, OnIsDragSourceChanged));
    
    public static bool GetIsDragSource(DependencyObject obj)
    {
        return (bool)obj.GetValue(IsDragSourceProperty);
    }
    
    public static void SetIsDragSource(DependencyObject obj, bool value)
    {
        obj.SetValue(IsDragSourceProperty, value);
    }
    
    private static void OnIsDragSourceChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
    {
        if (d is ListBox listBox && (bool)e.NewValue)
        {
            listBox.PointerPressed += ListBox_PointerPressed;
        }
    }
    
    private static void ListBox_PointerPressed(object sender, PointerPressedEventArgs e)
    {
        var listBox = sender as ListBox;
        var item = listBox?.SelectedItem;
        
        if (item != null)
        {
            var data = new DataObject();
            data.Set("Item", item);
            DragDrop.DoDragDrop(e, data, DragDropEffects.Move);
        }
    }
}

<ListBox ItemsSource="{Binding AvailableTasks}"
         local:DragDropBehavior.IsDragSource="True" />

// Зміна курсору
targetListBox.AddHandler(DragDrop.DragOverEvent, (s, e) =>
{
    if (e.Data.Contains("TaskItem"))
    {
        e.DragEffects = DragDropEffects.Move;
        // Курсор автоматично змінюється на "move"
    }
    else
    {
        e.DragEffects = DragDropEffects.None;
        // Курсор "заборонено"
    }
});

// Підсвічування цільового контролу
targetListBox.AddHandler(DragDrop.DragEnterEvent, (s, e) =>
{
    targetListBox.Background = new SolidColorBrush(Color.FromRgb(229, 231, 235));
});

targetListBox.AddHandler(DragDrop.DragLeaveEvent, (s, e) =>
{
    targetListBox.Background = Brushes.White;
});

// Рекурсивний підрахунок всіх файлів у дереві
public int CountAllFiles(FileSystemItem item)
{
    int count = 0;
    
    // Базовий випадок: якщо це файл, повертаємо 1
    if (item.Type != FileSystemItemType.Folder)
        return 1;
    
    // Рекурсивний випадок: підраховуємо файли у всіх дочірніх елементах
    foreach (var child in item.Children)
    {
        count += CountAllFiles(child);  // Виклик самої себе!
    }
    
    return count;
}

// Рекурсивний пошук файлу по імені
public FileSystemItem FindFile(FileSystemItem root, string fileName)
{
    // Базовий випадок: знайшли файл
    if (root.Name == fileName)
        return root;
    
    // Рекурсивний випадок: шукаємо у дочірніх елементах
    foreach (var child in root.Children)
    {
        var result = FindFile(child, fileName);
        if (result != null)
            return result;
    }
    
    return null;  // Не знайдено
}

var root = new FolderItem
{
    Name = "C:\\",
    Children = new ObservableCollection<FolderItem>
    {
        new FolderItem
        {
            Name = "Program Files",
            Children = new ObservableCollection<FolderItem>
            {
                new FolderItem { Name = "App1" },
                new FolderItem { Name = "App2" }
            }
        }
    }
};

public class Project
{
    public string Name { get; set; }
    public ObservableCollection<Category> Categories { get; set; }
}

public class Category
{
    public string Name { get; set; }
    public ObservableCollection<Task> Tasks { get; set; }
}

public class Task
{
    public string Title { get; set; }
    public string Description { get; set; }
    public TaskPriority Priority { get; set; }
    public bool IsCompleted { get; set; }
}