// src/lib/utils/keyboardNavigation.ts
export interface NavigationContext {
  currentFocus: string | null;
  hierarchyContainer: HTMLElement;
  selectionStore: SelectionStore;
}

export class KeyboardNavigationController {
  private context: NavigationContext;
  
  constructor(context: NavigationContext) {
    this.context = context;
  }
  
  /**
   * Handle keyboard navigation events
   */
  handleKeydown(event: KeyboardEvent): boolean {
    const { key, shiftKey, ctrlKey, metaKey } = event;
    
    switch (key) {
      case 'ArrowUp':
        return this.handleArrowUp(shiftKey, ctrlKey);
      case 'ArrowDown':
        return this.handleArrowDown(shiftKey, ctrlKey);
      case 'ArrowLeft':
        return this.handleArrowLeft(shiftKey);
      case 'ArrowRight':
        return this.handleArrowRight(shiftKey);
      case 'Home':
        return this.handleHome(shiftKey);
      case 'End':
        return this.handleEnd(shiftKey);
      case ' ':
        return this.handleSpace(shiftKey, ctrlKey);
      case 'a':
        if (ctrlKey || metaKey) {
          return this.handleSelectAll(shiftKey);
        }
        break;
      default:
        return false;
    }
    
    return false;
  }
  
  private handleArrowUp(shiftKey: boolean, ctrlKey: boolean): boolean {
    const prevBlock = this.findPreviousBlock();
    if (\!prevBlock) return false;
    
    if (shiftKey) {
      this.context.selectionStore.extendRange(prevBlock.id);
    } else if (\!ctrlKey) {
      this.context.selectionStore.selectBlock(prevBlock.id);
    }
    
    this.moveFocusTo(prevBlock.element);
    return true;
  }
  
  private handleArrowDown(shiftKey: boolean, ctrlKey: boolean): boolean {
    const nextBlock = this.findNextBlock();
    if (\!nextBlock) return false;
    
    if (shiftKey) {
      this.context.selectionStore.extendRange(nextBlock.id);
    } else if (\!ctrlKey) {
      this.context.selectionStore.selectBlock(nextBlock.id);
    }
    
    this.moveFocusTo(nextBlock.element);
    return true;
  }
  
  private handleSpace(shiftKey: boolean, ctrlKey: boolean): boolean {
    const focusedBlock = this.getFocusedBlock();
    if (\!focusedBlock) return false;
    
    if (shiftKey) {
      // Range selection from last anchor
      this.context.selectionStore.extendRange(focusedBlock.id);
    } else if (ctrlKey) {
      // Multi-select toggle
      this.context.selectionStore.toggleBlock(focusedBlock.id);
    } else {
      // Single selection
      this.context.selectionStore.selectBlock(focusedBlock.id);
    }
    
    return true;
  }
  
  private handleSelectAll(shiftKey: boolean): boolean {
    const allBlocks = this.getAllBlocksInContext();
    
    if (shiftKey) {
      // Select all children of focused block
      const focusedBlock = this.getFocusedBlock();
      if (focusedBlock) {
        const childBlocks = this.getChildBlocks(focusedBlock.id);
        childBlocks.forEach(block => {
          this.context.selectionStore.addToSelection(block.id);
        });
      }
    } else {
      // Select all blocks in current context
      allBlocks.forEach(block => {
        this.context.selectionStore.addToSelection(block.id);
      });
    }
    
    return true;
  }
  
  private findPreviousBlock(): { id: string; element: HTMLElement } | null {
    const currentFocus = this.getFocusedBlock();
    if (\!currentFocus) return null;
    
    const allBlocks = this.getAllVisibleBlocks();
    const currentIndex = allBlocks.findIndex(block => block.id === currentFocus.id);
    
    if (currentIndex > 0) {
      return allBlocks[currentIndex - 1];
    }
    
    return null;
  }
  
  private findNextBlock(): { id: string; element: HTMLElement } | null {
    const currentFocus = this.getFocusedBlock();
    if (\!currentFocus) return null;
    
    const allBlocks = this.getAllVisibleBlocks();
    const currentIndex = allBlocks.findIndex(block => block.id === currentFocus.id);
    
    if (currentIndex < allBlocks.length - 1) {
      return allBlocks[currentIndex + 1];
    }
    
    return null;
  }
  
  private moveFocusTo(element: HTMLElement): void {
    element.focus();
    this.scrollIntoViewIfNeeded(element);
  }
  
  private scrollIntoViewIfNeeded(element: HTMLElement): void {
    const rect = element.getBoundingClientRect();
    const containerRect = this.context.hierarchyContainer.getBoundingClientRect();
    
    if (rect.top < containerRect.top || rect.bottom > containerRect.bottom) {
      element.scrollIntoView({ behavior: 'smooth', block: 'nearest' });
    }
  }
  
  private getAllVisibleBlocks(): Array<{ id: string; element: HTMLElement }> {
    const blockElements = this.context.hierarchyContainer.querySelectorAll(
      '[data-block-id]:not([hidden]):not(.collapsed)'
    );
    
    return Array.from(blockElements).map(el => ({
      id: el.getAttribute('data-block-id')\!,
      element: el as HTMLElement
    }));
  }
  
  private getFocusedBlock(): { id: string; element: HTMLElement } | null {
    const activeElement = document.activeElement as HTMLElement;
    const blockId = activeElement?.getAttribute('data-block-id');
    
    if (blockId) {
      return { id: blockId, element: activeElement };
    }
    
    return null;
  }
  
  private getAllBlocksInContext(): Array<{ id: string; element: HTMLElement }> {
    // Implementation depends on hierarchy context definition
    return this.getAllVisibleBlocks();
  }
  
  private getChildBlocks(parentId: string): Array<{ id: string; element: HTMLElement }> {
    // Find all blocks that are children of the specified parent
    const parentElement = this.context.hierarchyContainer.querySelector(
      `[data-block-id="${parentId}"]`
    ) as HTMLElement;
    
    if (\!parentElement) return [];
    
    const childContainer = parentElement.querySelector('.node-children');
    if (\!childContainer) return [];
    
    const childElements = childContainer.querySelectorAll('[data-block-id]');
    
    return Array.from(childElements).map(el => ({
      id: el.getAttribute('data-block-id')\!,
      element: el as HTMLElement
    }));
  }
}

// src/lib/stores/selectionStore.ts - Keyboard methods extension
interface SelectionStore extends Readable<SelectionState> {
  // ... existing methods
  
  // Keyboard-specific methods
  selectAll(blockIds: string[]): void;
  selectAllInContext(contextElement: HTMLElement): void;
  extendRangeInDirection(direction: 'up' | 'down'): void;
  moveSelectionFocus(targetId: string, maintainSelection: boolean): void;
}

class SelectionStoreImpl implements SelectionStore {
  // ... existing implementation
  
  selectAll(blockIds: string[]): void {
    this._store.update(state => ({
      ...state,
      selectedBlocks: [...blockIds],
      mode: blockIds.length > 1 ? 'multi' : 'single',
      lastActionType: 'multi-add'
    }));
  }
  
  selectAllInContext(contextElement: HTMLElement): void {
    const blockElements = contextElement.querySelectorAll('[data-block-id]');
    const blockIds = Array.from(blockElements)
      .map(el => el.getAttribute('data-block-id'))
      .filter(id => id \!== null) as string[];
    
    this.selectAll(blockIds);
  }
  
  extendRangeInDirection(direction: 'up' | 'down'): void {
    // Implementation for keyboard range extension
    this._store.update(state => {
      if (state.selectedBlocks.length === 0) return state;
      
      const lastSelected = state.selectedBlocks[state.selectedBlocks.length - 1];
      // Logic to find next block in specified direction
      // and extend range selection
      
      return {
        ...state,
        direction,
        lastActionType: 'range'
      };
    });
  }
  
  moveSelectionFocus(targetId: string, maintainSelection: boolean): void {
    if (\!maintainSelection) {
      this.selectBlock(targetId);
    }
    // Focus management happens in navigation controller
  }
}