using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using Microsoft.Maui.Controls;

namespace CommanderApp;

public partial class MainPage : ContentPage, INotifyPropertyChanged
{
    private readonly IFileSystemService _fileService;

    public ObservableCollection<FileSystemItem> LeftItems { get; } = new();
    public ObservableCollection<FileSystemItem> RightItems { get; } = new();

    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;

    public string LeftPath
    {
        get => _leftPath;
        set
        {
            if (_leftPath != value)
            {
                _leftPath = value;
                NotifyPropertyChanged();
            }
        }
    }

    public string RightPath
    {
        get => _rightPath;
        set
        {
            if (_rightPath != value)
            {
                _rightPath = value;
                NotifyPropertyChanged();
            }
        }
    }

    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)
    {
        InitializeComponent();
        _fileService = fileService;
        BindingContext = this;

        // Инициализация шаблонов
        InitializeCollectionViews();

        var root = _fileService.GetRootPath();
        LoadDirectory(root, true);
        LoadDirectory(root, false);

        // Устанавливаем фокус на страницу
        this.Focus();
    }

    private void InitializeCollectionViews()
    {
        LeftPanel.ItemTemplate = PanelCollectionView.CreateItemTemplate(isLeftPanel: true, page: this);
        RightPanel.ItemTemplate = PanelCollectionView.CreateItemTemplate(isLeftPanel: true, page: this);
    }


    protected override void OnHandlerChanged()
    {
        base.OnHandlerChanged();
        this.Focus();
    }

    public void HandleItemClick(FileSystemItem item, bool isLeftPanel)
    {
        if (_lastIsLeftPanel == isLeftPanel && _lastClickedItem == item)
        {
            // Двойной клик
            if (isLeftPanel)
                OnLeftItemDoubleTapped(item);
            else
                OnRightItemDoubleTapped(item);
        }
        else
        {
            // Одинарный клик - выделение
            if (isLeftPanel)
            {
                _isLeftPanelActive = true;
                _leftSelectedIndex = LeftItems.IndexOf(item);
                _selectedLeftItem = item;
                _selectedRightItem = null;
            }
            else
            {
                _isLeftPanelActive = false;
                _rightSelectedIndex = RightItems.IndexOf(item);
                _selectedRightItem = item;
                _selectedLeftItem = null;
            }
            UpdateVisualSelection();
        }
        _lastIsLeftPanel = isLeftPanel;
        _lastClickedItem = item;
    }

    private void LoadDirectory(string path, bool isLeft)
    {
        var items = _fileService.GetDirectoryContents(path).ToList();

        if (isLeft)
        {
            LeftItems.Clear();
            foreach (var item in items) LeftItems.Add(item);
            _currentLeftPath = path;
            LeftPath = path;

            // Сбрасываем выделение при загрузке новой директории
            _leftSelectedIndex = items.Count > 0 ? 0 : -1;
        }
        else
        {
            RightItems.Clear();
            foreach (var item in items) RightItems.Add(item);
            _currentRightPath = path;
            RightPath = path;

            _rightSelectedIndex = items.Count > 0 ? 0 : -1;
        }

        UpdateVisualSelection();
    }

    // Переключаем фокус с указанием направления
    private void MoveFocus(bool moveForward = true)
    {
        var allFocusable = GetFocusableElements();
        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)
    {
        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];
    }

    // Предыдущий элемент (для Up/Shift+Tab)
    private View GetPreviousFocusable(View current, List<View> allElements)
    {
        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];
    }

    private List<View> GetFocusableElements()
    {
        return this.GetVisualTreeDescendants()
            .OfType<View>()
            .Where(x => x.IsEnabled && x.IsVisible)
            .OrderBy(GetVisualTreeOrder) // Сортируем по порядку в визуальном дереве
            .ToList();
    }

    private int GetVisualTreeOrder(View view)
    {
        // Простой способ - используем порядок в визуальном дереве
        var parent = view.Parent as Layout;
        if (parent != null)
        {
            var index = parent.Children.IndexOf(view);
            return index >= 0 ? index : 0;
        }
        return 0;
    }

    // Обработчики выделения (вызываются при изменении Selection в CollectionView)
    private void OnLeftSelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (e.CurrentSelection.FirstOrDefault() is FileSystemItem selectedItem)
        {
            _leftSelectedIndex = LeftItems.IndexOf(selectedItem);
            _isLeftPanelActive = true;

            System.Diagnostics.Debug.WriteLine($"L !!! {_leftSelectedIndex} {_lastLeftSelectedIndex}");
            if (_lastLeftSelectedIndex < LeftItems.Count && _lastLeftSelectedIndex >= 0)
            {
                // Автоматически переключаем фокус при достижении границ
                if (_leftSelectedIndex > _lastLeftSelectedIndex)
                {
                    // Достигли конца списка - переходим к следующему элементу
                    MoveFocus(moveForward: true);
                }
                else if (_leftSelectedIndex < _lastLeftSelectedIndex)
                {
                    // Достигли начала списка - переходим к предыдущему элементу
                    MoveFocus(moveForward: false);
                }
            }

            UpdateVisualSelection();
        }
    }

    private void OnRightSelectionChanged(object sender, SelectionChangedEventArgs e)
    {
        if (e.CurrentSelection.FirstOrDefault() is FileSystemItem selectedItem)
        {
            _rightSelectedIndex = RightItems.IndexOf(selectedItem);
            _isLeftPanelActive = false;

            System.Diagnostics.Debug.WriteLine($"R !!! {_rightSelectedIndex} {_lastRightSelectedIndex}");
            if (_rightSelectedIndex < RightItems.Count && _rightSelectedIndex >= 0)
            {
                // Автоматически переключаем фокус при достижении границ
                if (_rightSelectedIndex > _lastRightSelectedIndex)
                {
                    // Достигли конца списка - переходим к следующему элементу
                    MoveFocus(moveForward: true);
                }
                else if (_rightSelectedIndex < _lastRightSelectedIndex)
                {
                    // Достигли начала списка - переходим к предыдущему элементу
                    MoveFocus(moveForward: false);
                }
            }

            UpdateVisualSelection();
        }
    }

    private void UpdateVisualSelection()
    {
        //Сбрасываем предыдущий фокус
        if (_currentFocusedButton != null)
        {
            VisualStateManager.GoToState(_currentFocusedButton, "Normal");
            _currentFocusedButton = null;
        }

        if (_isLeftPanelActive && _leftSelectedIndex >= 0 && _leftSelectedIndex < LeftItems.Count)
        {
            var item = LeftItems[_leftSelectedIndex];
            SetFocusToItem(LeftPanel, item);
            _selectedLeftItem = item;
            _selectedRightItem = null;
        }
        else if (!_isLeftPanelActive && _rightSelectedIndex >= 0 && _rightSelectedIndex < RightItems.Count)
        {
            var item = RightItems[_rightSelectedIndex];
            SetFocusToItem(RightPanel, item);
            _selectedRightItem = item;
            _selectedLeftItem = null;
        }
    }

    private void SetFocusToItem(CollectionView collectionView, FileSystemItem item)
    {
        // Используем Dispatcher чтобы дождаться рендеринга
        //Dispatcher.Dispatch(() =>
        //{
            var container = FindButtonContainer(collectionView, item);
            if (container is Button button)
            {
                VisualStateManager.GoToState(button, "Focused");
                _currentFocusedButton = button;
                _lastClickedItem = item;

                // Простой способ - используем текущие индексы
                if (_isLeftPanelActive)
                {
                    _lastLeftSelectedIndex = _leftSelectedIndex;
                }
                else
                {
                    _lastRightSelectedIndex = _rightSelectedIndex;
                }

                // Прокручиваем к выбранному элементу
                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)
            {
                return button;
            }
        }
        return null;
    }

    public void OnLeftItemDoubleTapped(FileSystemItem item)
    {
        if (item.IsDirectory)
        {
            LoadDirectory(item.FullName, true);
        }
    }

    public void OnRightItemDoubleTapped(FileSystemItem item)
    {
        if (item.IsDirectory)
        {
            LoadDirectory(item.FullName, false);
        }
    }

    // Остальные методы без изменений
    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) =>
        {
            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)
        {
            if (item.IsDirectory)
                Directory.Delete(item.FullName, recursive: true);
            else
                File.Delete(item.FullName);

            LoadDirectory(_currentLeftPath, true);
            LoadDirectory(_currentRightPath, false);
        }
    }

    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
        {
            await DisplayAlert("Error", "Folder already exists.", "OK");
        }
    }

    private void OnExitClicked(object sender, EventArgs e)
    {
        Application.Current?.Quit();
    }

    private async Task CopyDirectory(string sourceDir, string targetDir)
    {
        Directory.CreateDirectory(targetDir);

        foreach (var file in Directory.GetFiles(sourceDir))
        {
            await Task.Run(() => File.Copy(file, Path.Combine(targetDir, Path.GetFileName(file)), overwrite: true));
        }

        foreach (var dir in Directory.GetDirectories(sourceDir))
        {
            await CopyDirectory(dir, Path.Combine(targetDir, Path.GetFileName(dir)));
        }
    }

    private async Task ProcessFileOperation(Func<string, string, Task> operation, string actionName)
    {
        var srcItem = _selectedLeftItem ?? _selectedRightItem;
        if (srcItem == null)
        {
            await DisplayAlert("Error", "Select a file or folder first.", "OK");
            return;
        }

        string destDir = (srcItem == _selectedLeftItem) ? _currentRightPath : _currentLeftPath;

        try
        {
            await operation(srcItem.FullName, destDir);
            LoadDirectory(_currentLeftPath, true);
            LoadDirectory(_currentRightPath, false);
        }
        catch (Exception ex)
        {
            await DisplayAlert("Error", $"{actionName} failed: {ex.Message}", "OK");
        }
    }

    public new event PropertyChangedEventHandler? PropertyChanged;

    protected virtual void NotifyPropertyChanged([CallerMemberName] string? propertyName = null)
    {
        PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
    }
}