From 31af132b311c4e5e62e8d382c520680ea9ffccb0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=D0=9F=D0=B8=D0=BB=D0=B8=D0=BF=D0=B5=D0=BD=D0=BA=D0=BE=20?=
 =?UTF-8?q?=D0=90=D0=BD=D0=B4=D1=80=D0=B5=D0=B8=CC=86=20=D0=91=D0=BE=D1=80?=
 =?UTF-8?q?=D0=B8=D1=81=D0=BE=D0=B2=D0=B8=D1=87?=
 <Pilipenko.A.Bo@sberbank.ru>
Date: Thu, 20 Nov 2025 21:44:26 +0300
Subject: [PATCH] =?UTF-8?q?=D1=80=D0=B5=D1=84=D0=B0=D0=BA=D1=82=D0=BE?=
 =?UTF-8?q?=D1=80=D0=B8=D0=BD=D0=B3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 App.xaml.cs              |  35 +-
 FileOperations.cs        | 129 +++++++
 FileSystemService.cs     |   4 -
 IFileOperations.cs       |  18 +
 IFileSystemService.cs    |  13 +-
 IKeyboardService.cs      |  13 +
 IPanelManager.cs         |  35 ++
 IPathHelper.cs           |  10 +
 KeyboardService.cs       | 129 +++++++
 MainPage.xaml            |  85 +++--
 MainPage.xaml.cs         | 761 ++++++++++++++++++++++-----------------
 MauiProgram.cs           |   2 +-
 MockFileOperations.cs    |  46 +++
 MockFileSystemItem.cs    |  34 ++
 MockFileSystemService.cs |  81 +++++
 MockKeyboardService.cs   |  17 +
 MockPanelManager.cs      |  50 +++
 MockPathHelper.cs        |  13 +
 PanelCollectionView.cs   |  58 ---
 PanelManager.cs          | 119 ++++++
 PathHelper.cs            |  28 ++
 README.md                | 174 ++++++++-
 22 files changed, 1411 insertions(+), 443 deletions(-)
 create mode 100644 FileOperations.cs
 create mode 100644 IFileOperations.cs
 create mode 100644 IKeyboardService.cs
 create mode 100644 IPanelManager.cs
 create mode 100644 IPathHelper.cs
 create mode 100644 KeyboardService.cs
 create mode 100644 MockFileOperations.cs
 create mode 100644 MockFileSystemItem.cs
 create mode 100644 MockFileSystemService.cs
 create mode 100644 MockKeyboardService.cs
 create mode 100644 MockPanelManager.cs
 create mode 100644 MockPathHelper.cs
 delete mode 100644 PanelCollectionView.cs
 create mode 100644 PanelManager.cs
 create mode 100644 PathHelper.cs

diff --git a/App.xaml.cs b/App.xaml.cs
index ebd66b4..46d1a1a 100644
--- a/App.xaml.cs
+++ b/App.xaml.cs
@@ -1,15 +1,28 @@
-namespace CommanderApp
+using CommanderApp.Services;
+using Microsoft.Extensions.DependencyInjection;
+
+namespace CommanderApp;
+
+public partial class App : Application
 {
-    public partial class App : Application
+    public App()
+    {
+        InitializeComponent();
+
+        var services = new ServiceCollection();
+        ConfigureServices(services);
+        var serviceProvider = services.BuildServiceProvider();
+
+        MainPage = serviceProvider.GetService<MainPage>();
+    }
+
+    private void ConfigureServices(ServiceCollection services)
     {
-        public App()
-        {
-            InitializeComponent();
-        }
-
-        protected override Window CreateWindow(IActivationState? activationState)
-        {
-            return new Window(new AppShell());
-        }
+        services.AddSingleton<IFileSystemService, FileSystemService>();
+        services.AddSingleton<IPanelManager, PanelManager>();
+        services.AddSingleton<IFileOperations, FileOperations>();
+        services.AddSingleton<IKeyboardService, KeyboardService>();
+        services.AddSingleton<IPathHelper, PathHelper>();
+        services.AddSingleton<MainPage>();
     }
 }
\ No newline at end of file
diff --git a/FileOperations.cs b/FileOperations.cs
new file mode 100644
index 0000000..5f0c295
--- /dev/null
+++ b/FileOperations.cs
@@ -0,0 +1,129 @@
+namespace CommanderApp.Services;
+
+public class FileOperations : IFileOperations
+{
+    public async Task<bool> CopyAsync(string sourcePath, string targetPath, bool overwrite = true)
+    {
+        try
+        {
+            await Task.Run(() => File.Copy(sourcePath, targetPath, overwrite));
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Copy failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> MoveAsync(string sourcePath, string targetPath, bool overwrite = true)
+    {
+        try
+        {
+            await Task.Run(() =>
+            {
+                if (File.Exists(targetPath) && overwrite)
+                    File.Delete(targetPath);
+                File.Move(sourcePath, targetPath);
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Move failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> DeleteAsync(string path)
+    {
+        try
+        {
+            await Task.Run(() =>
+            {
+                if (Directory.Exists(path))
+                    Directory.Delete(path, true);
+                else if (File.Exists(path))
+                    File.Delete(path);
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Delete failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> CreateDirectoryAsync(string path)
+    {
+        try
+        {
+            await Task.Run(() => Directory.CreateDirectory(path));
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"CreateDirectory failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> OpenFileAsync(string filePath)
+    {
+        try
+        {
+            await Task.Run(() =>
+            {
+#if WINDOWS
+                System.Diagnostics.Process.Start(new System.Diagnostics.ProcessStartInfo
+                {
+                    FileName = filePath,
+                    UseShellExecute = true
+                });
+#else
+                var process = new System.Diagnostics.Process();
+                process.StartInfo.FileName = "open";
+                process.StartInfo.Arguments = $"\"{filePath}\"";
+                process.StartInfo.UseShellExecute = false;
+                process.Start();
+#endif
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"OpenFile failed: {ex.Message}");
+            return false;
+        }
+    }
+
+    public async Task<bool> CopyDirectoryAsync(string sourceDir, string targetDir)
+    {
+        try
+        {
+            await Task.Run(() =>
+            {
+                Directory.CreateDirectory(targetDir);
+
+                foreach (var file in Directory.GetFiles(sourceDir))
+                {
+                    var destFile = Path.Combine(targetDir, Path.GetFileName(file));
+                    File.Copy(file, destFile, true);
+                }
+
+                foreach (var directory in Directory.GetDirectories(sourceDir))
+                {
+                    var destDir = Path.Combine(targetDir, Path.GetFileName(directory));
+                    CopyDirectoryAsync(directory, destDir).Wait();
+                }
+            });
+            return true;
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"CopyDirectory failed: {ex.Message}");
+            return false;
+        }
+    }
+}
\ No newline at end of file
diff --git a/FileSystemService.cs b/FileSystemService.cs
index 80838bd..cb618d6 100644
--- a/FileSystemService.cs
+++ b/FileSystemService.cs
@@ -1,6 +1,5 @@
 using System.IO;
 using System.Linq;
-using Microsoft.Maui.Storage;
 
 namespace CommanderApp;
 
@@ -12,14 +11,12 @@ public class FileSystemService : IFileSystemService
         return FileSystem.AppDataDirectory;
 #else
         var path = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
-        // Убедимся, что путь корректен
         return Path.GetFullPath(path);
 #endif
     }
 
     public IEnumerable<FileSystemItem> GetDirectoryContents(string path)
     {
-        // Нормализуем путь
         path = Path.GetFullPath(path.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar));
 
         if (!Directory.Exists(path))
@@ -65,7 +62,6 @@ public class FileSystemService : IFileSystemService
         catch (Exception ex)
         {
             System.Diagnostics.Debug.WriteLine($"Error reading directory {path}: {ex.Message}");
-            // Возвращаем хотя бы ".." если возможно
             if (items.Count == 0 && Directory.GetParent(path) != null)
             {
                 items.Add(new FileSystemItem
diff --git a/IFileOperations.cs b/IFileOperations.cs
new file mode 100644
index 0000000..1a62cd0
--- /dev/null
+++ b/IFileOperations.cs
@@ -0,0 +1,18 @@
+namespace CommanderApp.Services;
+
+public interface IFileOperations
+{
+    Task<bool> CopyAsync(string sourcePath, string targetPath, bool overwrite = true);
+    Task<bool> MoveAsync(string sourcePath, string targetPath, bool overwrite = true);
+    Task<bool> DeleteAsync(string path);
+    Task<bool> CreateDirectoryAsync(string path);
+    Task<bool> OpenFileAsync(string filePath);
+    Task<bool> CopyDirectoryAsync(string sourceDir, string targetDir);
+}
+
+public class FileOperationResult
+{
+    public bool Success { get; set; }
+    public string Message { get; set; } = string.Empty;
+    public Exception Exception { get; set; }
+}
\ No newline at end of file
diff --git a/IFileSystemService.cs b/IFileSystemService.cs
index 1947800..cfc820c 100644
--- a/IFileSystemService.cs
+++ b/IFileSystemService.cs
@@ -1,8 +1,7 @@
-namespace CommanderApp
+namespace CommanderApp;
+
+public interface IFileSystemService
 {
-    public interface IFileSystemService
-    {
-        IEnumerable<FileSystemItem> GetDirectoryContents(string path);
-        string GetRootPath();
-    }
-}
+    string GetRootPath();
+    IEnumerable<FileSystemItem> GetDirectoryContents(string path);
+}
\ No newline at end of file
diff --git a/IKeyboardService.cs b/IKeyboardService.cs
new file mode 100644
index 0000000..0af10ea
--- /dev/null
+++ b/IKeyboardService.cs
@@ -0,0 +1,13 @@
+namespace CommanderApp.Services;
+
+public interface IKeyboardService
+{
+    void SetupKeyboardHandling(ContentPage page);
+    event EventHandler<KeyPressedEventArgs> KeyPressed;
+}
+
+public class KeyPressedEventArgs : EventArgs
+{
+    public string Key { get; set; } = string.Empty;
+    public string Platform { get; set; } = string.Empty;
+}
\ No newline at end of file
diff --git a/IPanelManager.cs b/IPanelManager.cs
new file mode 100644
index 0000000..1c3d52a
--- /dev/null
+++ b/IPanelManager.cs
@@ -0,0 +1,35 @@
+using System.Collections.ObjectModel;
+
+namespace CommanderApp.Services;
+
+public interface IPanelManager
+{
+    event EventHandler<PanelStateChangedEventArgs> StateChanged;
+    
+    bool IsLeftPanelActive { get; }
+    FileSystemItem SelectedItem { get; }
+    string ActivePanelPath { get; }
+    string LeftPanelPath { get; }
+    string RightPanelPath { get; }
+    int LeftSelectedIndex { get; }
+    int RightSelectedIndex { get; }
+    
+    void SwitchToLeftPanel();
+    void SwitchToRightPanel();
+    void MoveSelection(int direction);
+    void SetSelection(int index, bool isLeftPanel);
+    void UpdatePanelPaths(string leftPath, string rightPath);
+    void ClearSelection();
+    
+    // Для привязки данных
+    ObservableCollection<FileSystemItem> LeftItems { get; }
+    ObservableCollection<FileSystemItem> RightItems { get; }
+}
+
+public class PanelStateChangedEventArgs : EventArgs
+{
+    public bool IsLeftPanelActive { get; set; }
+    public int LeftSelectedIndex { get; set; }
+    public int RightSelectedIndex { get; set; }
+    public FileSystemItem SelectedItem { get; set; }
+}
\ No newline at end of file
diff --git a/IPathHelper.cs b/IPathHelper.cs
new file mode 100644
index 0000000..772a3f2
--- /dev/null
+++ b/IPathHelper.cs
@@ -0,0 +1,10 @@
+namespace CommanderApp.Services;
+
+public interface IPathHelper
+{
+    string GetUserHomePath();
+    string GetRootPath();
+    string CombinePaths(params string[] paths);
+    string GetFileName(string path);
+    string GetDirectoryName(string path);
+}
\ No newline at end of file
diff --git a/KeyboardService.cs b/KeyboardService.cs
new file mode 100644
index 0000000..864af70
--- /dev/null
+++ b/KeyboardService.cs
@@ -0,0 +1,129 @@
+#if WINDOWS
+using Microsoft.UI.Xaml.Input;
+using Windows.System;
+#endif
+
+namespace CommanderApp.Services;
+
+public class KeyboardService : IKeyboardService
+{
+    public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+    public void SetupKeyboardHandling(ContentPage page)
+    {
+#if WINDOWS
+        SetupWindowsKeyboardHandling(page);
+#elif MACCATALYST
+        SetupMacKeyboardHandling(page);
+#endif
+    }
+
+#if WINDOWS
+    private void SetupWindowsKeyboardHandling(ContentPage page)
+    {
+        try
+        {
+            if (page.Handler?.PlatformView is Microsoft.UI.Xaml.FrameworkElement frameworkElement)
+            {
+                frameworkElement.KeyDown += OnWindowsKeyDown;
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Windows keyboard setup error: {ex.Message}");
+        }
+    }
+
+    private void OnWindowsKeyDown(object sender, KeyRoutedEventArgs e)
+    {
+        var key = e.Key switch
+        {
+            VirtualKey.W => "w",
+            VirtualKey.S => "s", 
+            VirtualKey.A => "a",
+            VirtualKey.D => "d",
+            VirtualKey.Space => " ",
+            VirtualKey.Enter => "enter",
+            VirtualKey.F5 => "f5",
+            VirtualKey.F6 => "f6", 
+            VirtualKey.F7 => "f7",
+            VirtualKey.F8 => "f8",
+            VirtualKey.F10 => "f10",
+            VirtualKey.H => "h",
+            _ => null
+        };
+
+        if (key != null)
+        {
+            KeyPressed?.Invoke(this, new KeyPressedEventArgs { Key = key, Platform = "Windows" });
+            e.Handled = true;
+        }
+    }
+#endif
+
+#if MACCATALYST
+    private void SetupMacKeyboardHandling(ContentPage page)
+    {
+        try
+        {
+            if (page.Handler?.PlatformView is UIKit.UIView uiView)
+            {
+                var keyHandler = new MacKeyHandler(OnMacKeyPressed);
+                keyHandler.Frame = uiView.Bounds;
+                keyHandler.AutoresizingMask = UIKit.UIViewAutoresizing.All;
+                uiView.AddSubview(keyHandler);
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Mac keyboard setup error: {ex.Message}");
+        }
+    }
+
+    private void OnMacKeyPressed(string key)
+    {
+        KeyPressed?.Invoke(this, new KeyPressedEventArgs { Key = key, Platform = "Mac" });
+    }
+
+    public class MacKeyHandler : UIKit.UIView
+    {
+        private readonly Action<string> _keyHandler;
+
+        public MacKeyHandler(Action<string> keyHandler)
+        {
+            _keyHandler = keyHandler;
+            this.BecomeFirstResponder();
+        }
+
+        public override bool CanBecomeFirstResponder => true;
+
+        public override UIKit.UIKeyCommand[] KeyCommands => new[]
+        {
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"w", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleW:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"s", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleS:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"a", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleA:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"d", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleD:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)" ", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleSpace:")),
+            UIKit.UIKeyCommand.Create((Foundation.NSString)"h", (UIKit.UIKeyModifierFlags)0, new ObjCRuntime.Selector("handleH:"))
+        };
+
+        [Foundation.Export("handleW:")]
+        void HandleW(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("w");
+
+        [Foundation.Export("handleS:")]
+        void HandleS(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("s");
+
+        [Foundation.Export("handleA:")]
+        void HandleA(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("a");
+
+        [Foundation.Export("handleD:")]
+        void HandleD(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("d");
+
+        [Foundation.Export("handleSpace:")]
+        void HandleSpace(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke(" ");
+
+        [Foundation.Export("handleH:")]
+        void HandleH(UIKit.UIKeyCommand cmd) => _keyHandler?.Invoke("h");
+    }
+#endif
+}
\ No newline at end of file
diff --git a/MainPage.xaml b/MainPage.xaml
index 8a0fca6..dc0db9c 100644
--- a/MainPage.xaml
+++ b/MainPage.xaml
@@ -1,51 +1,61 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <ContentPage xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
-             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
-             x:Class="CommanderApp.MainPage"
-             Title="MAUI Commander">
+                xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
+                x:Class="CommanderApp.MainPage"
+                Title="MAUI Commander">
 
     <Grid RowDefinitions="Auto, Auto, *, Auto" ColumnDefinitions="*, *">
         <!-- Пути -->
         <Label Text="{Binding LeftPath}" 
-               Grid.Row="1" Grid.Column="0"
-               Padding="12,6"
-               FontSize="14"
-               FontAttributes="Bold"
-               BackgroundColor="#f0f0f0"
-               TextColor="Black"
-               VerticalTextAlignment="Center"
-               LineBreakMode="MiddleTruncation" />
+                Grid.Row="1" Grid.Column="0"
+                Padding="12,6"
+                FontSize="14"
+                FontAttributes="Bold"
+                BackgroundColor="#f0f0f0"
+                TextColor="Black"
+                VerticalTextAlignment="Center"
+                LineBreakMode="MiddleTruncation" />
 
         <Label Text="{Binding RightPath}" 
-               Grid.Row="1" Grid.Column="1"
-               Padding="12,6"
-               FontSize="14"
-               FontAttributes="Bold"
-               BackgroundColor="#f0f0f0"
-               TextColor="Black"
-               VerticalTextAlignment="Center"
-               LineBreakMode="MiddleTruncation" />
+                Grid.Row="1" Grid.Column="1"
+                Padding="12,6"
+                FontSize="14"
+                FontAttributes="Bold"
+                BackgroundColor="#f0f0f0"
+                TextColor="Black"
+                VerticalTextAlignment="Center"
+                LineBreakMode="MiddleTruncation" />
 
         <!-- Левая панель -->
-        <CollectionView x:Name="LeftPanel"
+        <ScrollView x:Name="LeftScrollView"
                 Grid.Row="2" Grid.Column="0"
-                ItemsSource="{Binding LeftItems}"
-                SelectionMode="Single"
-                SelectionChanged="OnLeftSelectionChanged"
-                ItemSizingStrategy="MeasureAllItems">
-        </CollectionView>
+                BackgroundColor="White">
+            <VerticalStackLayout x:Name="LeftPanel" Spacing="0"/>
+        </ScrollView>
 
         <!-- Правая панель -->
-        <CollectionView x:Name="RightPanel"
+        <ScrollView x:Name="RightScrollView"
                 Grid.Row="2" Grid.Column="1"
-                ItemsSource="{Binding RightItems}"
-                SelectionMode="Single"
-                SelectionChanged="OnRightSelectionChanged"
-                ItemSizingStrategy="MeasureAllItems">
-        </CollectionView>
+                BackgroundColor="White">
+            <VerticalStackLayout x:Name="RightPanel" Spacing="0"/>
+        </ScrollView>
+
+        <!-- Визуальные индикаторы активной панели -->
+        <BoxView x:Name="LeftPanelIndicator"
+                Grid.Row="2" Grid.Column="0"
+                BackgroundColor="Transparent"
+                HeightRequest="3"
+                VerticalOptions="Start"/>
+                
+        <BoxView x:Name="RightPanelIndicator"
+                Grid.Row="2" Grid.Column="1"
+                BackgroundColor="Transparent"
+                HeightRequest="3"
+                VerticalOptions="Start"/>
 
         <!-- Toolbar -->
-        <FlexLayout Grid.Row="3"
+        <FlexLayout x:Name="ToolbarLayout"
+            Grid.Row="3"
             Grid.ColumnSpan="2"
             Padding="10"
             BackgroundColor="Transparent"
@@ -54,11 +64,12 @@
             JustifyContent="Center"
             AlignItems="Center">
 
-            <Button Text="F5 Copy"   Clicked="OnCopyClicked"   Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
-            <Button Text="F6 Move"   Clicked="OnMoveClicked"   Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
-            <Button Text="F7 Mkdir"  Clicked="OnMkdirClicked"  Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
-            <Button Text="F8 Delete" Clicked="OnDeleteClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
-            <Button Text="F10 Exit"  Clicked="OnExitClicked"   Padding="12,6" MinimumWidthRequest="80" Margin="0,0,0,8" />
+            <Button x:Name="CopyButton" Text="F5 Copy" Clicked="OnCopyClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="MoveButton" Text="F6 Move" Clicked="OnMoveClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="MkdirButton" Text="F7 Mkdir" Clicked="OnMkdirClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="DeleteButton" Text="F8 Delete" Clicked="OnDeleteClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="HomeButton" Text="Home" Clicked="OnHomeClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,8,8" />
+            <Button x:Name="ExitButton" Text="F10 Exit" Clicked="OnExitClicked" Padding="12,6" MinimumWidthRequest="80" Margin="0,0,0,8" />
 
         </FlexLayout>
     </Grid>
diff --git a/MainPage.xaml.cs b/MainPage.xaml.cs
index f6f55ae..5c42f4e 100644
--- a/MainPage.xaml.cs
+++ b/MainPage.xaml.cs
@@ -1,6 +1,6 @@
-using System.Collections.ObjectModel;
-using System.ComponentModel;
+using System.ComponentModel;
 using System.Runtime.CompilerServices;
+using CommanderApp.Services;
 using Microsoft.Maui.Controls;
 
 namespace CommanderApp;
@@ -8,468 +8,583 @@ namespace CommanderApp;
 public partial class MainPage : ContentPage, INotifyPropertyChanged
 {
     private readonly IFileSystemService _fileService;
+    private readonly IPanelManager _panelManager;
+    private readonly IFileOperations _fileOperations;
+    private readonly IKeyboardService _keyboardService;
+    private readonly IPathHelper _pathHelper;
 
-    public ObservableCollection<FileSystemItem> LeftItems { get; } = new();
-    public ObservableCollection<FileSystemItem> RightItems { get; } = new();
+    // Для визуального выделения
+    private readonly Color ActiveIndicatorColor = Color.FromArgb("#007ACC");
+    private readonly Color InactiveIndicatorColor = Colors.Transparent;
+    private readonly Color FocusedButtonColor = Color.FromArgb("#E3F2FD");
+    private readonly Color NormalButtonColor = Colors.Transparent;
 
-    private string _leftPath = string.Empty;
-    private string _rightPath = string.Empty;
-
-    // Для управления выделением и фокусом
-    private Button? _currentFocusedButton;
-    private bool _isLeftPanelActive = true;
-    private int _leftSelectedIndex = -1;
-    private int _rightSelectedIndex = -1;
+    // Для отслеживания двойного клика
+    private DateTime _lastClickTime = DateTime.MinValue;
+    private object _lastClickedButton = null;
 
     public string LeftPath
     {
-        get => _leftPath;
+        get => _panelManager.LeftPanelPath;
         set
         {
-            if (_leftPath != value)
+            if (_panelManager.LeftPanelPath != value)
             {
-                _leftPath = value;
-                NotifyPropertyChanged();
+                _panelManager.UpdatePanelPaths(value, _panelManager.RightPanelPath);
+                OnPropertyChanged();
             }
         }
     }
 
     public string RightPath
     {
-        get => _rightPath;
+        get => _panelManager.RightPanelPath;
         set
         {
-            if (_rightPath != value)
+            if (_panelManager.RightPanelPath != value)
             {
-                _rightPath = value;
-                NotifyPropertyChanged();
+                _panelManager.UpdatePanelPaths(_panelManager.LeftPanelPath, value);
+                OnPropertyChanged();
             }
         }
     }
 
-    private string _currentLeftPath = string.Empty;
-    private string _currentRightPath = string.Empty;
-
-    private FileSystemItem? _selectedLeftItem;
-    private FileSystemItem? _selectedRightItem;
-
-    // Для двойного нажатия
-    private FileSystemItem? _lastClickedItem;
-    private int _lastLeftSelectedIndex = 0;
-    private int _lastRightSelectedIndex = 0;
-    private bool? _lastIsLeftPanel;
-
-    public MainPage(IFileSystemService fileService)
+    public MainPage(IFileSystemService fileService, 
+                    IPanelManager panelManager,
+                    IFileOperations fileOperations,
+                    IKeyboardService keyboardService,
+                    IPathHelper pathHelper)
     {
         InitializeComponent();
+        
         _fileService = fileService;
+        _panelManager = panelManager;
+        _fileOperations = fileOperations;
+        _keyboardService = keyboardService;
+        _pathHelper = pathHelper;
+        
         BindingContext = this;
 
-        // Инициализация шаблонов
-        InitializeCollectionViews();
+        System.Diagnostics.Debug.WriteLine("=== MainPage constructor ===");
+
+        // Подписываемся на события
+        _panelManager.StateChanged += OnPanelStateChanged;
+        _keyboardService.KeyPressed += OnKeyPressed;
 
+        // Загружаем начальные директории
         var root = _fileService.GetRootPath();
         LoadDirectory(root, true);
         LoadDirectory(root, false);
 
-        // Устанавливаем фокус на страницу
-        this.Focus();
+        System.Diagnostics.Debug.WriteLine("=== MainPage constructor completed ===");
     }
 
-    private void InitializeCollectionViews()
+    protected override void OnAppearing()
     {
-        LeftPanel.ItemTemplate = PanelCollectionView.CreateItemTemplate(isLeftPanel: true, page: this);
-        RightPanel.ItemTemplate = PanelCollectionView.CreateItemTemplate(isLeftPanel: false, page: this);
+        base.OnAppearing();
+        System.Diagnostics.Debug.WriteLine("=== OnAppearing ===");
+        
+        Dispatcher.Dispatch(async () =>
+        {
+            await Task.Delay(300);
+            SetInitialFocus();
+        });
     }
 
+    protected override void OnHandlerChanged()
+    {
+        base.OnHandlerChanged();
+        System.Diagnostics.Debug.WriteLine($"=== OnHandlerChanged ===");
+        
+        _keyboardService.SetupKeyboardHandling(this);
+    }
 
-    //protected override void OnHandlerChanged()
-    //{
-    //    base.OnHandlerChanged();
-    //    this.Focus();
-    //}
-
-    public void HandleItemClick(FileSystemItem item, bool isLeftPanel)
+    private void OnKeyPressed(object sender, KeyPressedEventArgs e)
     {
-        if (_lastIsLeftPanel == isLeftPanel && _lastClickedItem == item)
-        {
-            // Двойной клик
-            if (isLeftPanel)
-                OnLeftItemDoubleTapped(item);
-            else
-                OnRightItemDoubleTapped(item);
-        }
-        else
+        System.Diagnostics.Debug.WriteLine($"=== KEY PRESSED: {e.Key} on {e.Platform} ===");
+        
+        MainThread.BeginInvokeOnMainThread(() =>
         {
-            // Одинарный клик - выделение
-            if (isLeftPanel)
-            {
-                _isLeftPanelActive = true;
-                _leftSelectedIndex = LeftItems.IndexOf(item);
-                _selectedLeftItem = item;
-                _selectedRightItem = null;
-            }
-            else
+            switch (e.Key)
             {
-                _isLeftPanelActive = false;
-                _rightSelectedIndex = RightItems.IndexOf(item);
-                _selectedRightItem = item;
-                _selectedLeftItem = null;
+                case "w": // W - вверх
+                    _panelManager.MoveSelection(-1);
+                    break;
+                case "s": // S - вниз
+                    _panelManager.MoveSelection(1);
+                    break;
+                case "a": // A - левая панель
+                    _panelManager.SwitchToLeftPanel();
+                    break;
+                case "d": // D - правая панель
+                    _panelManager.SwitchToRightPanel();
+                    break;
+                case " ": // Space - вход/запуск
+                case "enter": // Enter - вход/запуск
+                    OpenSelectedItem();
+                    break;
+                case "f5": // F5 - Копирование
+                    OnCopyClicked(this, EventArgs.Empty);
+                    break;
+                case "f6": // F6 - Перемещение
+                    OnMoveClicked(this, EventArgs.Empty);
+                    break;
+                case "f7": // F7 - Создать папку
+                    OnMkdirClicked(this, EventArgs.Empty);
+                    break;
+                case "f8": // F8 - Удаление
+                    OnDeleteClicked(this, EventArgs.Empty);
+                    break;
+                case "f10": // F10 - Выход
+                    OnExitClicked(this, EventArgs.Empty);
+                    break;
+                case "h": // H - Home
+                    OnHomeClicked(this, EventArgs.Empty);
+                    break;
             }
-            UpdateVisualSelection();
-        }
-        _lastIsLeftPanel = isLeftPanel;
-        _lastClickedItem = item;
+        });
     }
 
-    private void LoadDirectory(string path, bool isLeft)
+    private void OnPanelStateChanged(object sender, PanelStateChangedEventArgs e)
     {
-        var items = _fileService.GetDirectoryContents(path).ToList();
-
-        if (isLeft)
+        UpdateVisualState();
+        
+        // Устанавливаем фокус на выбранный элемент
+        if (e.IsLeftPanelActive && e.LeftSelectedIndex >= 0 && e.LeftSelectedIndex < LeftPanel.Children.Count)
         {
-            LeftItems.Clear();
-            foreach (var item in items) LeftItems.Add(item);
-            _currentLeftPath = path;
-            LeftPath = path;
-
-            // Сбрасываем выделение при загрузке новой директории
-            _leftSelectedIndex = items.Count > 0 ? 0 : -1;
+            var button = LeftPanel.Children[e.LeftSelectedIndex] as Button;
+            button?.Focus();
         }
-        else
+        else if (!e.IsLeftPanelActive && e.RightSelectedIndex >= 0 && e.RightSelectedIndex < RightPanel.Children.Count)
         {
-            RightItems.Clear();
-            foreach (var item in items) RightItems.Add(item);
-            _currentRightPath = path;
-            RightPath = path;
-
-            _rightSelectedIndex = items.Count > 0 ? 0 : -1;
+            var button = RightPanel.Children[e.RightSelectedIndex] as Button;
+            button?.Focus();
         }
-
-        UpdateVisualSelection();
-    }
-
-    // Переключаем фокус с указанием направления
-    private void MoveFocus(bool moveForward, bool isLeft)
-    {
-        var allFocusable = GetFocusableElements(isLeft);
-        var current = allFocusable.FirstOrDefault(x => x.IsFocused);
-        var next = moveForward ?
-                GetNextFocusable(current, allFocusable) :
-                GetPreviousFocusable(current, allFocusable);
-
-        next?.Focus();
     }
 
-    // Следующий элемент (для Down/Tab)
-    private View GetNextFocusable(View current, List<View> allElements)
+    private void SetInitialFocus()
     {
-        if (current == null) return allElements.FirstOrDefault();
-
-        var currentIndex = allElements.IndexOf(current);
-        if (currentIndex == -1) return allElements.FirstOrDefault();
-
-        var nextIndex = (currentIndex + 1) % allElements.Count;
-        return allElements[nextIndex];
+        try
+        {
+            System.Diagnostics.Debug.WriteLine("=== Setting initial focus ===");
+            
+            if (LeftPanel.Children.Count > 0)
+            {
+                var firstButton = LeftPanel.Children[0] as Button;
+                if (firstButton != null)
+                {
+                    var focused = firstButton.Focus();
+                    System.Diagnostics.Debug.WriteLine($"First button focus result: {focused}");
+                    
+                    if (focused)
+                    {
+                        _panelManager.SetSelection(0, true);
+                    }
+                }
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error setting initial focus: {ex.Message}");
+        }
     }
 
-    // Предыдущий элемент (для Up/Shift+Tab)
-    private View GetPreviousFocusable(View current, List<View> allElements)
+    private void OpenSelectedItem()
     {
-        if (current == null) return allElements.LastOrDefault();
-
-        var currentIndex = allElements.IndexOf(current);
-        if (currentIndex == -1) return allElements.LastOrDefault();
-
-        var prevIndex = (currentIndex - 1 + allElements.Count) % allElements.Count;
-        return allElements[prevIndex];
+        var item = _panelManager.SelectedItem;
+            
+        if (item != null)
+        {
+            System.Diagnostics.Debug.WriteLine($"Opening: {item.Name} (IsDirectory: {item.IsDirectory})");
+            
+            if (item.IsDirectory)
+            {
+                LoadDirectory(item.FullName, _panelManager.IsLeftPanelActive);
+            }
+            else
+            {
+                _ = _fileOperations.OpenFileAsync(item.FullName);
+            }
+        }
+        else
+        {
+            System.Diagnostics.Debug.WriteLine("No item selected");
+        }
     }
 
-    private List<View> GetFocusableElements(bool isLeft)
+    private void UpdateVisualState()
     {
-        List<View>? elements = null;
-        if (isLeft)
+        // Визуальное выделение активной панели
+        if (_panelManager.IsLeftPanelActive)
         {
-            elements = LeftPanel.GetVisualTreeDescendants().OfType<View>()
-            .Where(x => x.IsEnabled && x.IsVisible && x is Button)
-            .OrderBy(GetVisualTreeOrder) // Сортируем по порядку в визуальном дереве
-            .ToList();
+            LeftPanelIndicator.BackgroundColor = ActiveIndicatorColor;
+            RightPanelIndicator.BackgroundColor = InactiveIndicatorColor;
         }
         else
         {
-            elements = RightPanel.GetVisualTreeDescendants().OfType<View>()
-            .Where(x => x.IsEnabled && x.IsVisible && x is Button)
-            .OrderBy(GetVisualTreeOrder) // Сортируем по порядку в визуальном дереве
-            .ToList();
+            LeftPanelIndicator.BackgroundColor = InactiveIndicatorColor;
+            RightPanelIndicator.BackgroundColor = ActiveIndicatorColor;
         }
 
-        //foreach (var el in elements)
-        //{
-        //    System.Diagnostics.Debug.WriteLine($"!!! {el.ToString()}");
-        //}
-
-        return elements;
+        UpdateButtonSelection();
     }
 
-    private int GetVisualTreeOrder(View view)
+    private void UpdateButtonSelection()
     {
-        // Простой способ - используем порядок в визуальном дереве
-        var parent = view.Parent as Layout;
-        if (parent != null)
+        // Сбрасываем выделение всех кнопок
+        foreach (var child in LeftPanel.Children)
+        {
+            if (child is Button button)
+            {
+                button.BackgroundColor = NormalButtonColor;
+            }
+        }
+        
+        foreach (var child in RightPanel.Children)
+        {
+            if (child is Button button)
+            {
+                button.BackgroundColor = NormalButtonColor;
+            }
+        }
+
+        // Выделяем активную кнопку
+        if (_panelManager.IsLeftPanelActive && _panelManager.LeftSelectedIndex >= 0 && _panelManager.LeftSelectedIndex < LeftPanel.Children.Count)
+        {
+            if (LeftPanel.Children[_panelManager.LeftSelectedIndex] is Button leftButton)
+            {
+                leftButton.BackgroundColor = FocusedButtonColor;
+            }
+        }
+        else if (!_panelManager.IsLeftPanelActive && _panelManager.RightSelectedIndex >= 0 && _panelManager.RightSelectedIndex < RightPanel.Children.Count)
         {
-            var index = parent.Children.IndexOf(view);
-            return index >= 0 ? index : 0;
+            if (RightPanel.Children[_panelManager.RightSelectedIndex] is Button rightButton)
+            {
+                rightButton.BackgroundColor = FocusedButtonColor;
+            }
         }
-        return 0;
     }
 
-    // Обработчики выделения (вызываются при изменении Selection в CollectionView)
-    private void OnLeftSelectionChanged(object sender, SelectionChangedEventArgs e)
+    private void LoadDirectory(string path, bool isLeft)
     {
-        if (e.CurrentSelection.FirstOrDefault() is FileSystemItem selectedItem)
+        try
         {
-            _leftSelectedIndex = LeftItems.IndexOf(selectedItem);
-            _isLeftPanelActive = true;
+            var items = _fileService.GetDirectoryContents(path).ToList();
+            var panel = isLeft ? LeftPanel : RightPanel;
+            var collection = isLeft ? _panelManager.LeftItems : _panelManager.RightItems;
 
-            // System.Diagnostics.Debug.WriteLine($"L !!! {_leftSelectedIndex} {_lastLeftSelectedIndex}");
-            if (_lastLeftSelectedIndex < LeftItems.Count && _lastLeftSelectedIndex >= 0)
+            panel.Children.Clear();
+            collection.Clear();
+
+            foreach (var item in items)
             {
-                // Автоматически переключаем фокус при достижении границ
-                if (_leftSelectedIndex > _lastLeftSelectedIndex)
-                {
-                    // Достигли конца списка - переходим к следующему элементу
-                    MoveFocus(moveForward: true, isLeft: true);
-                }
-                else if (_leftSelectedIndex < _lastLeftSelectedIndex)
-                {
-                    // Достигли начала списка - переходим к предыдущему элементу
-                    MoveFocus(moveForward: false, isLeft: true);
-                }
+                collection.Add(item);
+                AddItemToPanel(item, panel, isLeft);
+            }
+
+            if (isLeft)
+            {
+                LeftPath = path;
+                _panelManager.SetSelection(items.Count > 0 ? 0 : -1, true);
+            }
+            else
+            {
+                RightPath = path;
+                _panelManager.SetSelection(items.Count > 0 ? 0 : -1, false);
             }
 
-            UpdateVisualSelection();
+            System.Diagnostics.Debug.WriteLine($"Loaded {items.Count} items to {(isLeft ? "LEFT" : "RIGHT")} panel");
+            UpdateVisualState();
+
+            // Устанавливаем фокус на первый элемент
+            if (items.Count > 0)
+            {
+                Dispatcher.Dispatch(() =>
+                {
+                    var firstButton = panel.Children[0] as Button;
+                    firstButton?.Focus();
+                });
+            }
+        }
+        catch (Exception ex)
+        {
+            System.Diagnostics.Debug.WriteLine($"Error loading directory: {ex.Message}");
+            DisplayAlert("Error", $"Cannot load directory: {ex.Message}", "OK");
         }
     }
 
-    private void OnRightSelectionChanged(object sender, SelectionChangedEventArgs e)
+    private void AddItemToPanel(FileSystemItem item, VerticalStackLayout panel, bool isLeft)
     {
-        if (e.CurrentSelection.FirstOrDefault() is FileSystemItem selectedItem)
+        var button = new Button
         {
-            _rightSelectedIndex = RightItems.IndexOf(selectedItem);
-            _isLeftPanelActive = false;
-
-            // System.Diagnostics.Debug.WriteLine($"R !!! {_rightSelectedIndex} {_lastRightSelectedIndex}");
-            if (_lastRightSelectedIndex < RightItems.Count && _lastRightSelectedIndex >= 0)
+            Text = item.DisplayText,
+            Padding = new Thickness(15, 8),
+            HeightRequest = 40,
+            BackgroundColor = NormalButtonColor,
+            HorizontalOptions = LayoutOptions.FillAndExpand,
+            TextColor = Colors.Black,
+            FontSize = 14,
+            BorderColor = Colors.Transparent,
+            CornerRadius = 0
+        };
+
+        // Обработчик клика - выделение при клике, открытие при двойном клике
+        button.Clicked += (s, e) => HandleItemClick(button, item, isLeft);
+
+        // Обработчик фокуса
+        button.Focused += (s, e) => 
+        {
+            var index = panel.Children.IndexOf(button);
+            if (index >= 0)
             {
-                // Автоматически переключаем фокус при достижении границ
-                if (_rightSelectedIndex > _lastRightSelectedIndex)
-                {
-                    // Достигли конца списка - переходим к следующему элементу
-                    MoveFocus(moveForward: true, isLeft: false);
-                }
-                else if (_rightSelectedIndex < _lastRightSelectedIndex)
-                {
-                    // Достигли начала списка - переходим к предыдущему элементу
-                    MoveFocus(moveForward: false, isLeft: false);
-                }
+                _panelManager.SetSelection(index, isLeft);
             }
+        };
 
-           UpdateVisualSelection();
-        }
+        panel.Children.Add(button);
     }
 
-    private void UpdateVisualSelection()
+    private void HandleItemClick(Button button, FileSystemItem item, bool isLeft)
     {
-        //Сбрасываем предыдущий фокус
-        if (_currentFocusedButton != null)
-        {
-            VisualStateManager.GoToState(_currentFocusedButton, "Normal");
-            _currentFocusedButton = null;
-        }
+        var currentTime = DateTime.Now;
+        var isDoubleClick = (currentTime - _lastClickTime).TotalMilliseconds < 500 
+                          && _lastClickedButton == button;
 
-        if (_isLeftPanelActive && _leftSelectedIndex >= 0 && _leftSelectedIndex < LeftItems.Count)
+        _lastClickTime = currentTime;
+        _lastClickedButton = button;
+
+        System.Diagnostics.Debug.WriteLine($"=== CLICK: {item.Name} in {(isLeft ? "LEFT" : "RIGHT")} panel, Double: {isDoubleClick} ===");
+
+        // ВСЕГДА выделяем элемент при клике
+        var panel = isLeft ? LeftPanel : RightPanel;
+        var index = panel.Children.IndexOf(button);
+        
+        if (index >= 0)
         {
-            var item = LeftItems[_leftSelectedIndex];
-            SetFocusToItem(LeftPanel, item);
-            _selectedLeftItem = item;
-            _selectedRightItem = null;
+            _panelManager.SetSelection(index, isLeft);
+            
+            // Устанавливаем фокус на кнопку
+            button.Focus();
         }
-        else if (!_isLeftPanelActive && _rightSelectedIndex >= 0 && _rightSelectedIndex < RightItems.Count)
+
+        // Если это двойной клик - открываем/запускаем
+        if (isDoubleClick)
         {
-            var item = RightItems[_rightSelectedIndex];
-            SetFocusToItem(RightPanel, item);
-            _selectedRightItem = item;
-            _selectedLeftItem = null;
+            if (item.IsDirectory)
+            {
+                LoadDirectory(item.FullName, isLeft);
+            }
+            else
+            {
+                _ = _fileOperations.OpenFileAsync(item.FullName);
+            }
         }
     }
 
-    private void SetFocusToItem(CollectionView collectionView, FileSystemItem item)
+    // Команды тулбара
+    private async void OnCopyClicked(object sender, EventArgs e)
     {
-        // Используем Dispatcher чтобы дождаться рендеринга
-        Dispatcher.Dispatch(() =>
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: F5 Copy ===");
+        
+        var sourceItem = _panelManager.SelectedItem;
+        var targetPath = _panelManager.IsLeftPanelActive ? RightPath : LeftPath;
+        
+        if (sourceItem != null)
         {
-            var container = FindButtonContainer(collectionView, item);
-            if (container is Button button)
+            try
             {
-                VisualStateManager.GoToState(button, "Focused");
-                _currentFocusedButton = button;
-                _lastClickedItem = item;
-
-                // Простой способ - используем текущие индексы
-                if (_isLeftPanelActive)
+                var targetFullPath = _pathHelper.CombinePaths(targetPath, sourceItem.Name);
+                
+                bool success;
+                if (sourceItem.IsDirectory)
                 {
-                    _lastLeftSelectedIndex = _leftSelectedIndex;
+                    success = await _fileOperations.CopyDirectoryAsync(sourceItem.FullName, targetFullPath);
+                    if (success)
+                        await DisplayAlert("Success", $"Directory '{sourceItem.Name}' copied successfully", "OK");
                 }
                 else
                 {
-                    _lastRightSelectedIndex = _rightSelectedIndex;
+                    success = await _fileOperations.CopyAsync(sourceItem.FullName, targetFullPath);
+                    if (success)
+                        await DisplayAlert("Success", $"File '{sourceItem.Name}' copied successfully", "OK");
+                }
+                
+                if (success)
+                {
+                    // Обновляем целевую панель
+                    LoadDirectory(targetPath, !_panelManager.IsLeftPanelActive);
+                }
+                else
+                {
+                    await DisplayAlert("Error", "Copy operation failed", "OK");
                 }
-
-                // Прокручиваем к выбранному элементу
-                collectionView.ScrollTo(item, position: ScrollToPosition.MakeVisible, animate: false);
             }
-        });
-    }
-
-    private Button? FindButtonContainer(CollectionView collectionView, FileSystemItem item)
-    {
-        // Ищем кнопку в логических дочерних элементах
-        foreach (var child in collectionView.LogicalChildren)
-        {
-            if (child is Button button && button.BindingContext == item)
+            catch (Exception ex)
             {
-                return button;
+                await DisplayAlert("Error", $"Copy failed: {ex.Message}", "OK");
             }
         }
-        return null;
-    }
-
-    public void OnLeftItemDoubleTapped(FileSystemItem item)
-    {
-        if (item.IsDirectory)
-        {
-            LoadDirectory(item.FullName, true);
-        }
-    }
-
-    public void OnRightItemDoubleTapped(FileSystemItem item)
-    {
-        if (item.IsDirectory)
+        else
         {
-            LoadDirectory(item.FullName, false);
+            await DisplayAlert("Info", "Please select an item to copy", "OK");
         }
     }
 
-    // Остальные методы без изменений
-    private async void OnCopyClicked(object sender, EventArgs e)
-    {
-        await ProcessFileOperation(async (src, destDir) =>
-        {
-            if (Directory.Exists(src))
-                await CopyDirectory(src, Path.Combine(destDir, Path.GetFileName(src)));
-            else
-                File.Copy(src, Path.Combine(destDir, Path.GetFileName(src)), overwrite: true);
-        }, "Copy");
-    }
-
     private async void OnMoveClicked(object sender, EventArgs e)
     {
-        await ProcessFileOperation((src, destDir) =>
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: F6 Move ===");
+        
+        var sourceItem = _panelManager.SelectedItem;
+        var targetPath = _panelManager.IsLeftPanelActive ? RightPath : LeftPath;
+        
+        if (sourceItem != null)
         {
-            var dest = Path.Combine(destDir, Path.GetFileName(src));
-            if (Directory.Exists(src))
-                Directory.Move(src, dest);
-            else
-                File.Move(src, dest, overwrite: true);
-            return Task.CompletedTask;
-        }, "Move");
-    }
-
-    private async void OnDeleteClicked(object sender, EventArgs e)
-    {
-        var item = _selectedLeftItem ?? _selectedRightItem;
-        if (item == null) return;
-
-        var confirm = await DisplayAlert("Delete", $"Delete '{item.Name}'?", "Yes", "No");
-        if (confirm)
+            try
+            {
+                var targetFullPath = _pathHelper.CombinePaths(targetPath, sourceItem.Name);
+                
+                bool success;
+                if (sourceItem.IsDirectory)
+                {
+                    success = await _fileOperations.CopyDirectoryAsync(sourceItem.FullName, targetFullPath);
+                    if (success)
+                        success = await _fileOperations.DeleteAsync(sourceItem.FullName);
+                }
+                else
+                {
+                    success = await _fileOperations.MoveAsync(sourceItem.FullName, targetFullPath);
+                }
+                
+                if (success)
+                {
+                    await DisplayAlert("Success", $"Item '{sourceItem.Name}' moved successfully", "OK");
+                    
+                    // Обновляем обе панели
+                    LoadDirectory(_panelManager.IsLeftPanelActive ? LeftPath : RightPath, _panelManager.IsLeftPanelActive);
+                    LoadDirectory(targetPath, !_panelManager.IsLeftPanelActive);
+                }
+                else
+                {
+                    await DisplayAlert("Error", "Move operation failed", "OK");
+                }
+            }
+            catch (Exception ex)
+            {
+                await DisplayAlert("Error", $"Move failed: {ex.Message}", "OK");
+            }
+        }
+        else
         {
-            if (item.IsDirectory)
-                Directory.Delete(item.FullName, recursive: true);
-            else
-                File.Delete(item.FullName);
-
-            LoadDirectory(_currentLeftPath, true);
-            LoadDirectory(_currentRightPath, false);
+            await DisplayAlert("Info", "Please select an item to move", "OK");
         }
     }
 
     private async void OnMkdirClicked(object sender, EventArgs e)
     {
-        var result = await DisplayPromptAsync("New Folder", "Folder name:", "Create", "Cancel");
-        if (string.IsNullOrWhiteSpace(result)) return;
-
-        string targetPath = (_selectedLeftItem != null || LeftItems.Count > 0) ? _currentLeftPath : _currentRightPath;
-        string newPath = Path.Combine(targetPath, result.Trim());
-
-        if (!Directory.Exists(newPath))
-        {
-            Directory.CreateDirectory(newPath);
-            LoadDirectory(_currentLeftPath, true);
-            LoadDirectory(_currentRightPath, false);
-        }
-        else
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: F7 Mkdir ===");
+        
+        var currentPath = _panelManager.IsLeftPanelActive ? LeftPath : RightPath;
+        
+        // Запрашиваем имя новой папки
+        var folderName = await DisplayPromptAsync("Create Folder", "Enter folder name:", "Create", "Cancel", "New Folder");
+        
+        if (!string.IsNullOrWhiteSpace(folderName))
         {
-            await DisplayAlert("Error", "Folder already exists.", "OK");
+            try
+            {
+                var newFolderPath = _pathHelper.CombinePaths(currentPath, folderName);
+                var success = await _fileOperations.CreateDirectoryAsync(newFolderPath);
+                
+                if (success)
+                {
+                    await DisplayAlert("Success", $"Folder '{folderName}' created successfully", "OK");
+                    
+                    // Обновляем текущую панель
+                    LoadDirectory(currentPath, _panelManager.IsLeftPanelActive);
+                }
+                else
+                {
+                    await DisplayAlert("Error", "Failed to create folder", "OK");
+                }
+            }
+            catch (Exception ex)
+            {
+                await DisplayAlert("Error", $"Cannot create folder: {ex.Message}", "OK");
+            }
         }
     }
 
-    private void OnExitClicked(object sender, EventArgs e)
-    {
-        Application.Current?.Quit();
-    }
-
-    private async Task CopyDirectory(string sourceDir, string targetDir)
+    private async void OnDeleteClicked(object sender, EventArgs e)
     {
-        Directory.CreateDirectory(targetDir);
-
-        foreach (var file in Directory.GetFiles(sourceDir))
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: F8 Delete ===");
+        
+        var item = _panelManager.SelectedItem;
+        
+        if (item != null)
         {
-            await Task.Run(() => File.Copy(file, Path.Combine(targetDir, Path.GetFileName(file)), overwrite: true));
+            // Подтверждение удаления
+            var result = await DisplayAlert("Confirm Delete", 
+                $"Are you sure you want to delete '{item.Name}'?", 
+                "Delete", "Cancel");
+            
+            if (result)
+            {
+                try
+                {
+                    var success = await _fileOperations.DeleteAsync(item.FullName);
+                    
+                    if (success)
+                    {
+                        await DisplayAlert("Success", $"Item '{item.Name}' deleted successfully", "OK");
+                        
+                        // Обновляем текущую панель
+                        LoadDirectory(_panelManager.IsLeftPanelActive ? LeftPath : RightPath, _panelManager.IsLeftPanelActive);
+                    }
+                    else
+                    {
+                        await DisplayAlert("Error", "Delete operation failed", "OK");
+                    }
+                }
+                catch (Exception ex)
+                {
+                    await DisplayAlert("Error", $"Delete failed: {ex.Message}", "OK");
+                }
+            }
         }
-
-        foreach (var dir in Directory.GetDirectories(sourceDir))
+        else
         {
-            await CopyDirectory(dir, Path.Combine(targetDir, Path.GetFileName(dir)));
+            await DisplayAlert("Info", "Please select an item to delete", "OK");
         }
     }
 
-    private async Task ProcessFileOperation(Func<string, string, Task> operation, string actionName)
+    private void OnHomeClicked(object sender, EventArgs e)
     {
-        var srcItem = _selectedLeftItem ?? _selectedRightItem;
-        if (srcItem == null)
-        {
-            await DisplayAlert("Error", "Select a file or folder first.", "OK");
-            return;
-        }
-
-        string destDir = (srcItem == _selectedLeftItem) ? _currentRightPath : _currentLeftPath;
-
+        System.Diagnostics.Debug.WriteLine("=== BUTTON: Home ===");
+        
         try
         {
-            await operation(srcItem.FullName, destDir);
-            LoadDirectory(_currentLeftPath, true);
-            LoadDirectory(_currentRightPath, false);
+            // Получаем домашнюю директорию пользователя
+            var homePath = _pathHelper.GetUserHomePath();
+            
+            // Переходим в домашнюю директорию на активной панели
+            LoadDirectory(homePath, _panelManager.IsLeftPanelActive);
+            
+            System.Diagnostics.Debug.WriteLine($"Navigated to home directory: {homePath}");
         }
         catch (Exception ex)
         {
-            await DisplayAlert("Error", $"{actionName} failed: {ex.Message}", "OK");
+            DisplayAlert("Error", $"Cannot navigate to home directory: {ex.Message}", "OK");
         }
     }
 
-    public new event PropertyChangedEventHandler? PropertyChanged;
+    private void OnExitClicked(object sender, EventArgs e) => Application.Current?.Quit();
 
-    protected virtual void NotifyPropertyChanged([CallerMemberName] string? propertyName = null)
+    // INotifyPropertyChanged
+    public event PropertyChangedEventHandler? PropertyChanged;
+    protected void SetProperty<T>(ref T field, T value, [CallerMemberName] string? propertyName = null)
     {
+        if (EqualityComparer<T>.Default.Equals(field, value)) return;
+        field = value;
         PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
     }
 }
\ No newline at end of file
diff --git a/MauiProgram.cs b/MauiProgram.cs
index 53c4ff6..5aaf904 100644
--- a/MauiProgram.cs
+++ b/MauiProgram.cs
@@ -16,7 +16,7 @@ namespace CommanderApp
                 });
 
 #if DEBUG
-    		builder.Logging.AddDebug();
+            builder.Logging.AddDebug();
 #endif
             builder.Services.AddSingleton<IFileSystemService, FileSystemService>();
             return builder.Build();
diff --git a/MockFileOperations.cs b/MockFileOperations.cs
new file mode 100644
index 0000000..59a4ab0
--- /dev/null
+++ b/MockFileOperations.cs
@@ -0,0 +1,46 @@
+namespace CommanderApp.Services;
+
+public class MockFileOperations : IFileOperations
+{
+    public List<string> CopiedFiles { get; } = new();
+    public List<string> MovedFiles { get; } = new();
+    public List<string> DeletedItems { get; } = new();
+    public List<string> CreatedDirectories { get; } = new();
+    public List<string> OpenedFiles { get; } = new();
+
+    public Task<bool> CopyAsync(string sourcePath, string targetPath, bool overwrite = true)
+    {
+        CopiedFiles.Add($"{sourcePath} -> {targetPath}");
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> MoveAsync(string sourcePath, string targetPath, bool overwrite = true)
+    {
+        MovedFiles.Add($"{sourcePath} -> {targetPath}");
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> DeleteAsync(string path)
+    {
+        DeletedItems.Add(path);
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> CreateDirectoryAsync(string path)
+    {
+        CreatedDirectories.Add(path);
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> OpenFileAsync(string filePath)
+    {
+        OpenedFiles.Add(filePath);
+        return Task.FromResult(true);
+    }
+
+    public Task<bool> CopyDirectoryAsync(string sourceDir, string targetDir)
+    {
+        CopiedFiles.Add($"DIR: {sourceDir} -> {targetDir}");
+        return Task.FromResult(true);
+    }
+}
\ No newline at end of file
diff --git a/MockFileSystemItem.cs b/MockFileSystemItem.cs
new file mode 100644
index 0000000..6192aa7
--- /dev/null
+++ b/MockFileSystemItem.cs
@@ -0,0 +1,34 @@
+namespace CommanderApp;
+
+public static class MockFileSystemItem
+{
+    public static FileSystemItem CreateDirectory(string name, string path)
+    {
+        return new FileSystemItem
+        {
+            Name = name,
+            FullName = path,
+            IsDirectory = true
+        };
+    }
+
+    public static FileSystemItem CreateFile(string name, string path)
+    {
+        return new FileSystemItem
+        {
+            Name = name,
+            FullName = path,
+            IsDirectory = false
+        };
+    }
+
+    public static FileSystemItem CreateParentDirectory(string path)
+    {
+        return new FileSystemItem
+        {
+            Name = "..",
+            FullName = path,
+            IsDirectory = true
+        };
+    }
+}
\ No newline at end of file
diff --git a/MockFileSystemService.cs b/MockFileSystemService.cs
new file mode 100644
index 0000000..4b5a225
--- /dev/null
+++ b/MockFileSystemService.cs
@@ -0,0 +1,81 @@
+namespace CommanderApp;
+
+public class MockFileSystemService : IFileSystemService
+{
+    public string MockRootPath { get; set; } = "/mock/root";
+    
+    private readonly Dictionary<string, List<FileSystemItem>> _mockDirectories = new();
+
+    public MockFileSystemService()
+    {
+        // Инициализируем mock данными
+        SetupMockData();
+    }
+
+    private void SetupMockData()
+    {
+        _mockDirectories["/mock/root"] = new List<FileSystemItem>
+        {
+            new FileSystemItem { Name = "Documents", FullName = "/mock/root/Documents", IsDirectory = true },
+            new FileSystemItem { Name = "Pictures", FullName = "/mock/root/Pictures", IsDirectory = true },
+            new FileSystemItem { Name = "readme.txt", FullName = "/mock/root/readme.txt", IsDirectory = false },
+            new FileSystemItem { Name = "..", FullName = "/mock", IsDirectory = true }
+        };
+
+        _mockDirectories["/mock/root/Documents"] = new List<FileSystemItem>
+        {
+            new FileSystemItem { Name = "Project1", FullName = "/mock/root/Documents/Project1", IsDirectory = true },
+            new FileSystemItem { Name = "Project2", FullName = "/mock/root/Documents/Project2", IsDirectory = true },
+            new FileSystemItem { Name = "notes.txt", FullName = "/mock/root/Documents/notes.txt", IsDirectory = false },
+            new FileSystemItem { Name = "..", FullName = "/mock/root", IsDirectory = true }
+        };
+
+        _mockDirectories["/mock/root/Pictures"] = new List<FileSystemItem>
+        {
+            new FileSystemItem { Name = "vacation.jpg", FullName = "/mock/root/Pictures/vacation.jpg", IsDirectory = false },
+            new FileSystemItem { Name = "..", FullName = "/mock/root", IsDirectory = true }
+        };
+    }
+
+    public string GetRootPath()
+    {
+        return MockRootPath;
+    }
+
+    public IEnumerable<FileSystemItem> GetDirectoryContents(string path)
+    {
+        if (_mockDirectories.ContainsKey(path))
+        {
+            return _mockDirectories[path];
+        }
+
+        // Если директории нет в mock данных, возвращаем пустой список с ".."
+        var parent = GetParentPath(path);
+        if (parent != null)
+        {
+            return new List<FileSystemItem>
+            {
+                new FileSystemItem { Name = "..", FullName = parent, IsDirectory = true }
+            };
+        }
+
+        return Enumerable.Empty<FileSystemItem>();
+    }
+
+    // Метод для добавления mock данных в тестах
+    public void AddMockDirectory(string path, List<FileSystemItem> items)
+    {
+        _mockDirectories[path] = items;
+    }
+
+    private string GetParentPath(string path)
+    {
+        var separator = '/';
+        var lastSeparator = path.LastIndexOf(separator);
+        if (lastSeparator > 0)
+        {
+            return path.Substring(0, lastSeparator);
+        }
+        return null;
+    }
+}
\ No newline at end of file
diff --git a/MockKeyboardService.cs b/MockKeyboardService.cs
new file mode 100644
index 0000000..a960d78
--- /dev/null
+++ b/MockKeyboardService.cs
@@ -0,0 +1,17 @@
+namespace CommanderApp.Services;
+
+public class MockKeyboardService : IKeyboardService
+{
+    public event EventHandler<KeyPressedEventArgs> KeyPressed;
+
+    public void SetupKeyboardHandling(ContentPage page)
+    {
+        // Mock implementation - does nothing
+    }
+
+    // Method to simulate key presses in tests
+    public void SimulateKeyPress(string key)
+    {
+        KeyPressed?.Invoke(this, new KeyPressedEventArgs { Key = key, Platform = "Test" });
+    }
+}
\ No newline at end of file
diff --git a/MockPanelManager.cs b/MockPanelManager.cs
new file mode 100644
index 0000000..59a1ff3
--- /dev/null
+++ b/MockPanelManager.cs
@@ -0,0 +1,50 @@
+using System.Collections.ObjectModel;
+
+namespace CommanderApp.Services;
+
+public class MockPanelManager : IPanelManager
+{
+    public event EventHandler<PanelStateChangedEventArgs> StateChanged;
+
+    public bool IsLeftPanelActive { get; set; } = true;
+    public FileSystemItem SelectedItem { get; set; }
+    public string ActivePanelPath { get; set; } = "/mock/path";
+    public string LeftPanelPath { get; set; } = "/left/path";
+    public string RightPanelPath { get; set; } = "/right/path";
+    public int LeftSelectedIndex { get; set; } = 0;
+    public int RightSelectedIndex { get; set; } = -1;
+
+    public ObservableCollection<FileSystemItem> LeftItems { get; } = new();
+    public ObservableCollection<FileSystemItem> RightItems { get; } = new();
+
+    public void SwitchToLeftPanel() => IsLeftPanelActive = true;
+    public void SwitchToRightPanel() => IsLeftPanelActive = false;
+    
+    public void MoveSelection(int direction)
+    {
+        if (IsLeftPanelActive)
+            LeftSelectedIndex = Math.Max(0, LeftSelectedIndex + direction);
+        else
+            RightSelectedIndex = Math.Max(0, RightSelectedIndex + direction);
+    }
+
+    public void SetSelection(int index, bool isLeftPanel)
+    {
+        if (isLeftPanel)
+            LeftSelectedIndex = index;
+        else
+            RightSelectedIndex = index;
+    }
+
+    public void UpdatePanelPaths(string leftPath, string rightPath)
+    {
+        LeftPanelPath = leftPath;
+        RightPanelPath = rightPath;
+    }
+
+    public void ClearSelection()
+    {
+        LeftSelectedIndex = -1;
+        RightSelectedIndex = -1;
+    }
+}
\ No newline at end of file
diff --git a/MockPathHelper.cs b/MockPathHelper.cs
new file mode 100644
index 0000000..e4417cc
--- /dev/null
+++ b/MockPathHelper.cs
@@ -0,0 +1,13 @@
+namespace CommanderApp.Services;
+
+public class MockPathHelper : IPathHelper
+{
+    public string MockHomePath { get; set; } = "/mock/home";
+    public string MockRootPath { get; set; } = "/mock/root";
+
+    public string GetUserHomePath() => MockHomePath;
+    public string GetRootPath() => MockRootPath;
+    public string CombinePaths(params string[] paths) => string.Join("/", paths);
+    public string GetFileName(string path) => System.IO.Path.GetFileName(path);
+    public string GetDirectoryName(string path) => System.IO.Path.GetDirectoryName(path) ?? string.Empty;
+}
\ No newline at end of file
diff --git a/PanelCollectionView.cs b/PanelCollectionView.cs
deleted file mode 100644
index 9d48180..0000000
--- a/PanelCollectionView.cs
+++ /dev/null
@@ -1,58 +0,0 @@
-using Microsoft.Maui.Controls;
-
-namespace CommanderApp;
-
-public static class PanelCollectionView
-{
-    public static DataTemplate CreateItemTemplate(bool isLeftPanel, MainPage page)
-    {
-        return new DataTemplate(() =>
-        {
-            var button = new Button
-            {
-                Padding = new Thickness(15, 8, 5, 8), // left, top, right, bottom
-                HeightRequest = 40,
-                BackgroundColor = Colors.Transparent,
-                BorderWidth = 0,
-                HorizontalOptions = LayoutOptions.Fill,
-            };
-
-            // Устанавливаем тематический цвет текста
-            button.SetAppThemeColor(Button.TextColorProperty, Colors.Black, Colors.White);
-            button.SetBinding(Button.TextProperty, new Binding("DisplayText"));
-            button.SetBinding(Button.CommandParameterProperty, new Binding("."));
-
-            // Обработчик нажатия
-            button.Clicked += (s, e) =>
-            {
-                if (s is Button btn && btn.CommandParameter is FileSystemItem item)
-                {
-                    page.HandleItemClick(item, isLeftPanel);
-                }
-            };
-
-            // Визуальные состояния для фокуса
-            var visualStateGroups = new VisualStateGroupList();
-            var commonStates = new VisualStateGroup { Name = "CommonStates" };
-
-            var normalState = new VisualState { Name = "Normal" };
-
-            var focusedState = new VisualState { Name = "Focused" };
-            focusedState.Setters.Add(new Setter { Property = Button.BorderColorProperty, Value = Colors.Blue });
-            focusedState.Setters.Add(new Setter { Property = Button.BorderWidthProperty, Value = 2 });
-
-            var pressedState = new VisualState { Name = "Pressed" };
-            pressedState.Setters.Add(new Setter { Property = Button.BackgroundColorProperty, Value = Color.FromArgb("#e0e0e0") });
-
-            commonStates.States.Add(normalState);
-            commonStates.States.Add(focusedState);
-            //commonStates.States.Add(pressedState);
-            visualStateGroups.Add(commonStates);
-
-            VisualStateManager.SetVisualStateGroups(button, visualStateGroups);
-
-            return button;
-        });
-    }
-
-}
\ No newline at end of file
diff --git a/PanelManager.cs b/PanelManager.cs
new file mode 100644
index 0000000..167ade7
--- /dev/null
+++ b/PanelManager.cs
@@ -0,0 +1,119 @@
+using System.Collections.ObjectModel;
+
+namespace CommanderApp.Services;
+
+public class PanelManager : IPanelManager
+{
+    public event EventHandler<PanelStateChangedEventArgs> StateChanged;
+
+    private bool _isLeftPanelActive = true;
+    private int _leftSelectedIndex = -1;
+    private int _rightSelectedIndex = -1;
+    private string _leftPanelPath = string.Empty;
+    private string _rightPanelPath = string.Empty;
+
+    public bool IsLeftPanelActive => _isLeftPanelActive;
+    public FileSystemItem SelectedItem => GetSelectedItem();
+    public string ActivePanelPath => _isLeftPanelActive ? _leftPanelPath : _rightPanelPath;
+    public string LeftPanelPath => _leftPanelPath;
+    public string RightPanelPath => _rightPanelPath;
+    public int LeftSelectedIndex => _leftSelectedIndex;
+    public int RightSelectedIndex => _rightSelectedIndex;
+
+    public ObservableCollection<FileSystemItem> LeftItems { get; } = new();
+    public ObservableCollection<FileSystemItem> RightItems { get; } = new();
+
+    public void SwitchToLeftPanel()
+    {
+        if (!_isLeftPanelActive && LeftItems.Count > 0)
+        {
+            _isLeftPanelActive = true;
+            OnStateChanged();
+        }
+    }
+
+    public void SwitchToRightPanel()
+    {
+        if (_isLeftPanelActive && RightItems.Count > 0)
+        {
+            _isLeftPanelActive = false;
+            OnStateChanged();
+        }
+    }
+
+    public void MoveSelection(int direction)
+    {
+        if (_isLeftPanelActive)
+        {
+            if (LeftItems.Count == 0) return;
+            var newIndex = Math.Max(0, Math.Min(LeftItems.Count - 1, _leftSelectedIndex + direction));
+            if (newIndex != _leftSelectedIndex)
+            {
+                _leftSelectedIndex = newIndex;
+                OnStateChanged();
+            }
+        }
+        else
+        {
+            if (RightItems.Count == 0) return;
+            var newIndex = Math.Max(0, Math.Min(RightItems.Count - 1, _rightSelectedIndex + direction));
+            if (newIndex != _rightSelectedIndex)
+            {
+                _rightSelectedIndex = newIndex;
+                OnStateChanged();
+            }
+        }
+    }
+
+    public void SetSelection(int index, bool isLeftPanel)
+    {
+        if (isLeftPanel)
+        {
+            if (index >= 0 && index < LeftItems.Count)
+            {
+                _leftSelectedIndex = index;
+                _isLeftPanelActive = true;
+            }
+        }
+        else
+        {
+            if (index >= 0 && index < RightItems.Count)
+            {
+                _rightSelectedIndex = index;
+                _isLeftPanelActive = false;
+            }
+        }
+        OnStateChanged();
+    }
+
+    public void UpdatePanelPaths(string leftPath, string rightPath)
+    {
+        _leftPanelPath = leftPath;
+        _rightPanelPath = rightPath;
+    }
+
+    public void ClearSelection()
+    {
+        _leftSelectedIndex = -1;
+        _rightSelectedIndex = -1;
+        OnStateChanged();
+    }
+
+    private FileSystemItem GetSelectedItem()
+    {
+        return _isLeftPanelActive ? 
+            (_leftSelectedIndex >= 0 ? LeftItems[_leftSelectedIndex] : null) :
+            (_rightSelectedIndex >= 0 ? RightItems[_rightSelectedIndex] : null);
+    }
+
+    private void OnStateChanged()
+    {
+        StateChanged?.Invoke(this, new PanelStateChangedEventArgs
+        {
+            IsLeftPanelActive = _isLeftPanelActive,
+            LeftSelectedIndex = _leftSelectedIndex,
+            RightSelectedIndex = _rightSelectedIndex,
+            SelectedItem = GetSelectedItem()
+        });
+    }
+}
\ No newline at end of file
diff --git a/PathHelper.cs b/PathHelper.cs
new file mode 100644
index 0000000..5433125
--- /dev/null
+++ b/PathHelper.cs
@@ -0,0 +1,28 @@
+namespace CommanderApp.Services;
+
+public class PathHelper : IPathHelper
+{
+    public string GetUserHomePath()
+    {
+#if WINDOWS
+        return Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+#else
+        return Environment.GetFolderPath(Environment.SpecialFolder.Personal);
+#endif
+    }
+
+    public string GetRootPath()
+    {
+#if WINDOWS
+        return Path.GetPathRoot(Environment.SystemDirectory) ?? "C:\\";
+#else
+        return "/";
+#endif
+    }
+
+    public string CombinePaths(params string[] paths) => Path.Combine(paths);
+
+    public string GetFileName(string path) => Path.GetFileName(path);
+
+    public string GetDirectoryName(string path) => Path.GetDirectoryName(path) ?? string.Empty;
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 059cae6..6fa12e7 100644
--- a/README.md
+++ b/README.md
@@ -1,3 +1,173 @@
-# commander
+## Файловый менеджер на .NET MAUI
 
-MAUI Commander
\ No newline at end of file
+**Разработчик:** Пилипенко Степан Андреевич (2025 год)
+
+---
+
+## Введение
+
+### Цель работы
+Разработка кроссплатформенного файлового менеджера с использованием современной технологии .NET MAUI, обеспечивающего эффективную работу с файловой системой на различных операционных системах.
+
+### Актуальность
+В современном мире с ростом мобильных устройств и разнообразием операционных систем возрастает потребность в кроссплатформенных решениях. Файловые менеджеры остаются одним из наиболее востребованных типов приложений, а возможность их работы на разных платформах из единой кодовой базы значительно сокращает затраты на разработку и поддержку.
+
+## Выбор технологий
+
+### .NET MAUI как основная платформа
+**Обоснование выбора:**
+
+1. **Единая кодовая база** - возможность разработки для Windows, macOS, Android и iOS из одного проекта
+2. **Производительность** - нативная компиляция и прямой доступ к API платформ
+3. **Современный UI** - поддержка последних стандартов пользовательского интерфейса
+4. **Экосистема .NET** - богатая библиотека компонентов и инструментов
+5. **Поддержка Microsoft** - долгосрочная поддержка и активное развитие платформы
+
+### Преимущества перед альтернативами
+- **По сравнению с Electron**: меньший расход памяти, лучшая производительность
+- **По сравнению с Flutter**: интеграция с экосистемой .NET, знакомый язык C#
+- **По сравнению с нативной разработкой**: сокращение времени разработки в 2-3 раза
+
+## Архитектура решения
+
+### Многослойная архитектура
+
+```
+┌─────────────────────────────────────────┐
+│             Presentation Layer          │
+│              (MainPage.xaml)            │
+└─────────────────────────────────────────┘
+┌─────────────────────────────────────────┐
+│              Business Logic             │
+│          (Сервисы, Менеджеры)           │
+└─────────────────────────────────────────┘
+┌─────────────────────────────────────────┐
+│              Data Access                │
+│        (FileSystemService, etc.)        │
+└─────────────────────────────────────────┘
+```
+
+### Ключевые компоненты
+
+#### 1. **Presentation Layer**
+- **MainPage.xaml** - основной пользовательский интерфейс
+- Две панели для навигации по файловой системе
+- Панель инструментов с основными операциями
+
+#### 2. **Business Logic Layer**
+
+##### PanelManager
+- Управление состоянием панелей
+- Навигация и выделение элементов
+- Координация между левой и правой панелями
+
+##### FileOperations
+- Копирование файлов и директорий
+- Перемещение элементов
+- Удаление и создание папок
+- Открытие файлов
+
+##### KeyboardService
+- Обработка клавиатурных сокращений
+- Кроссплатформенная поддержка горячих клавиш
+- Навигация с помощью WASD
+
+#### 3. **Data Access Layer**
+
+##### FileSystemService
+- Абстракция над файловой системой
+- Получение содержимого директорий
+- Кроссплатформенные пути
+
+##### PathHelper
+- Работа с путями файловой системы
+- Определение домашней директории
+- Кроссплатформенные операции с путями
+
+### Принципы проектирования
+
+#### 1. **Инверсия зависимостей (DIP)**
+```csharp
+public interface IPanelManager
+public interface IFileOperations
+public interface IKeyboardService
+```
+
+#### 2. **Принцип единственной ответственности (SRP)**
+Каждый сервис отвечает за конкретную функциональность
+
+#### 3. **Интерфейс-ориентированное программирование**
+Легкая замена реализаций и тестирование
+
+## Функциональные возможности
+
+### Основные операции
+1. **Навигация** - просмотр файловой системы через две панели
+2. **Копирование** (F5) - копирование файлов и папок между панелями
+3. **Перемещение** (F6) - перемещение элементов между панелями
+4. **Создание папок** (F7) - создание новых директорий
+5. **Удаление** (F8) - удаление файлов и папок
+6. **Быстрая навигация** - переход в домашнюю директорию
+
+### Управление с клавиатуры
+- **WASD** - навигация по файлам
+- **Space/Enter** - открытие файлов и папок
+- **F5-F8** - операции с файлами
+- **H** - переход в домашнюю директорию
+
+### Кроссплатформенность
+- Поддержка Windows и macOS
+- Единый код для разных платформ
+- Адаптация к особенностям файловых систем
+
+## Технические особенности
+
+### Обработка файловых операций
+```csharp
+public async Task<bool> CopyAsync(string sourcePath, string targetPath)
+public async Task<bool> MoveAsync(string sourcePath, string targetPath)
+public async Task<bool> DeleteAsync(string path)
+```
+
+### Навигационная система
+- Рекурсивный обход директорий
+- Поддержка специальных элементов (".." для навигации вверх)
+- Оптимизированная работа с большими директориями
+
+### Пользовательский интерфейс
+- Интуитивная двухпанельная layout
+- Визуальное выделение активных элементов
+- Статус-бар с текущими путями
+
+## Результаты разработки
+
+### Достигнутые цели
+1. ✅ Создан полнофункциональный файловый менеджер
+2. ✅ Обеспечена кроссплатформенность (Windows/macOS)
+3. ✅ Реализованы все основные файловые операции
+4. ✅ Обеспечена высокая производительность
+5. ✅ Создан удобный пользовательский интерфейс
+
+### Производительность
+- Быстрая загрузка директорий
+- Эффективная работа с большими файлами
+- Минимальное потребление памяти
+
+### Качество кода
+- Чистая архитектура с разделением ответственности
+- Полная покрытие интерфейсами для тестирования
+- Современные практики C# и .NET
+
+## Заключение
+
+Разработанный файловый менеджер демонстрирует эффективность использования .NET MAUI для создания кроссплатформенных приложений. Приложение успешно решает поставленные задачи и предоставляет пользователю удобный инструмент для работы с файловой системой на разных платформах.
+
+### Перспективы развития
+1. Добавление поддержки сетевых протоколов (FTP, SFTP)
+2. Реализация поиска по файловой системе
+3. Добавление предпросмотра файлов
+4. Поддержка плагинов и расширений
+5. Интеграция с облачными хранилищами
+
+### Выводы
+Использование .NET MAUI позволило создать производительное кроссплатформенное приложение с минимальными затратами на разработку. Архитектура на основе сервисов и интерфейсов обеспечивает легкую расширяемость и поддерживаемость кода, что делает решение перспективным для дальнейшего развития.
\ No newline at end of file