/**
 * KeyboardManager - Gestionnaire des raccourcis clavier
 * 
 * Responsabilités:
 * - Gérer la navigation par flèches (haut/bas pour codes, gauche/droite pour preuves)
 * - Gérer Ctrl+Enter pour valider le séjour
 * - Gérer Ctrl+E pour ouvrir le modal de correction
 * - Gérer Ctrl+F pour activer la recherche
 * - Gérer ? pour afficher l'aide
 * - Désactiver les raccourcis quand un modal est ouvert
 * 
 * Validates: Requirements 10.1, 10.2, 10.3, 10.4, 10.5, 10.6, 10.7, 10.8, 10.9
 */
class KeyboardManager {
  constructor(stateManager) {
    this.stateManager = stateManager;
    this.enabled = true;
    this.shortcuts = this.getShortcuts();
    
    this.init();
  }

  /**
   * Définir les raccourcis clavier
   */
  getShortcuts() {
    return {
      'ArrowDown': {
        description: 'Sélectionner le code suivant',
        handler: () => this.selectNextCode()
      },
      'ArrowUp': {
        description: 'Sélectionner le code précédent',
        handler: () => this.selectPreviousCode()
      },
      'ArrowRight': {
        description: 'Naviguer vers la preuve suivante',
        handler: () => this.nextEvidence()
      },
      'ArrowLeft': {
        description: 'Naviguer vers la preuve précédente',
        handler: () => this.previousEvidence()
      },
      'Ctrl+Enter': {
        description: 'Valider le séjour',
        handler: () => this.validateStay()
      },
      'Ctrl+e': {
        description: 'Ouvrir le modal de correction',
        handler: () => this.openCorrectionModal()
      },
      'Ctrl+f': {
        description: 'Activer la recherche',
        handler: () => this.activateSearch()
      },
      '?': {
        description: 'Afficher l\'aide des raccourcis',
        handler: () => this.showHelp()
      }
    };
  }

  /**
   * Initialiser le gestionnaire
   */
  init() {
    document.addEventListener('keydown', (e) => this.handleKeyDown(e));
    
    // Désactiver les raccourcis quand un modal est ouvert
    this.observeModals();
  }

  /**
   * Gérer les événements clavier
   */
  handleKeyDown(event) {
    // Ne pas traiter si les raccourcis sont désactivés
    if (!this.enabled) return;
    
    // Ne pas traiter si un champ de saisie est actif
    if (this.isInputActive()) return;
    
    // Construire la clé du raccourci
    let key = '';
    if (event.ctrlKey) key += 'Ctrl+';
    if (event.shiftKey) key += 'Shift+';
    if (event.altKey) key += 'Alt+';
    key += event.key;
    
    // Chercher le raccourci
    const shortcut = this.shortcuts[key];
    if (shortcut) {
      event.preventDefault();
      shortcut.handler();
    }
  }

  /**
   * Vérifier si un champ de saisie est actif
   * Validates: Requirements 10.9
   */
  isInputActive() {
    const activeElement = document.activeElement;
    const tagName = activeElement.tagName.toLowerCase();
    
    return (
      tagName === 'input' ||
      tagName === 'textarea' ||
      tagName === 'select' ||
      activeElement.isContentEditable
    );
  }

  /**
   * Observer les modals pour désactiver les raccourcis
   * Validates: Requirements 10.9
   */
  observeModals() {
    const observer = new MutationObserver(() => {
      const modals = document.querySelectorAll('.modal');
      let hasOpenModal = false;
      
      modals.forEach(modal => {
        if (modal.style.display === 'block' || modal.classList.contains('active')) {
          hasOpenModal = true;
        }
      });
      
      this.enabled = !hasOpenModal;
    });
    
    observer.observe(document.body, {
      attributes: true,
      subtree: true,
      attributeFilter: ['style', 'class']
    });
  }

  /**
   * Sélectionner le code suivant
   * Validates: Requirements 10.1
   */
  selectNextCode() {
    const stay = this.stateManager.getCurrentStay();
    if (!stay) return;
    
    const allCodes = this.getAllCodes(stay);
    const selectedCode = this.stateManager.getSelectedCode();
    
    if (!selectedCode) {
      // Sélectionner le premier code
      if (allCodes.length > 0) {
        this.stateManager.setSelectedCode(allCodes[0]);
      }
      return;
    }
    
    // Trouver l'index du code actuel
    const currentIndex = allCodes.findIndex(c => c.code === selectedCode.code);
    if (currentIndex < allCodes.length - 1) {
      this.stateManager.setSelectedCode(allCodes[currentIndex + 1]);
    }
  }

  /**
   * Sélectionner le code précédent
   * Validates: Requirements 10.2
   */
  selectPreviousCode() {
    const stay = this.stateManager.getCurrentStay();
    if (!stay) return;
    
    const allCodes = this.getAllCodes(stay);
    const selectedCode = this.stateManager.getSelectedCode();
    
    if (!selectedCode) {
      // Sélectionner le dernier code
      if (allCodes.length > 0) {
        this.stateManager.setSelectedCode(allCodes[allCodes.length - 1]);
      }
      return;
    }
    
    // Trouver l'index du code actuel
    const currentIndex = allCodes.findIndex(c => c.code === selectedCode.code);
    if (currentIndex > 0) {
      this.stateManager.setSelectedCode(allCodes[currentIndex - 1]);
    }
  }

  /**
   * Obtenir tous les codes d'un séjour
   */
  getAllCodes(stay) {
    const codes = [];
    
    if (stay.codes.dp) {
      codes.push({ ...stay.codes.dp, type: 'dp' });
    }
    if (stay.codes.dr) {
      codes.push({ ...stay.codes.dr, type: 'dr' });
    }
    if (stay.codes.das) {
      stay.codes.das.forEach(code => codes.push({ ...code, type: 'das' }));
    }
    if (stay.codes.ccam) {
      stay.codes.ccam.forEach(code => codes.push({ ...code, type: 'ccam' }));
    }
    
    return codes;
  }

  /**
   * Naviguer vers la preuve suivante
   * Validates: Requirements 10.3
   */
  nextEvidence() {
    const selectedCode = this.stateManager.getSelectedCode();
    if (!selectedCode || !selectedCode.evidence || selectedCode.evidence.length === 0) {
      return;
    }
    
    // TODO: Implémenter la navigation entre preuves
    console.log('Naviguer vers la preuve suivante');
  }

  /**
   * Naviguer vers la preuve précédente
   * Validates: Requirements 10.4
   */
  previousEvidence() {
    const selectedCode = this.stateManager.getSelectedCode();
    if (!selectedCode || !selectedCode.evidence || selectedCode.evidence.length === 0) {
      return;
    }
    
    // TODO: Implémenter la navigation entre preuves
    console.log('Naviguer vers la preuve précédente');
  }

  /**
   * Valider le séjour
   * Validates: Requirements 10.5
   */
  validateStay() {
    const stay = this.stateManager.getCurrentStay();
    if (!stay) return;
    
    if (confirm('Voulez-vous valider ce séjour ?')) {
      // TODO: Appeler l'API pour valider
      alert('Séjour validé');
    }
  }

  /**
   * Ouvrir le modal de correction
   * Validates: Requirements 10.6
   */
  openCorrectionModal() {
    const selectedCode = this.stateManager.getSelectedCode();
    if (!selectedCode) {
      alert('Veuillez d\'abord sélectionner un code');
      return;
    }
    
    const modal = document.getElementById('correctionModal');
    if (modal) {
      document.getElementById('originalCode').value = selectedCode.code;
      document.getElementById('correctedCode').value = '';
      document.getElementById('correctedLabel').value = '';
      document.getElementById('correctionComment').value = '';
      modal.style.display = 'block';
    }
  }

  /**
   * Activer la recherche
   * Validates: Requirements 10.7
   */
  activateSearch() {
    const searchInput = document.getElementById('document-search-input');
    if (searchInput) {
      searchInput.focus();
    }
  }

  /**
   * Afficher l'aide des raccourcis
   * Validates: Requirements 10.8
   */
  showHelp() {
    let html = `
      <div class="modal" id="helpModal" style="display: block;">
        <div class="modal-content">
          <div class="modal-header">
            <h3>⌨️ Raccourcis Clavier</h3>
            <span class="close" onclick="document.getElementById('helpModal').remove()">&times;</span>
          </div>
          <div class="shortcuts-list">
    `;
    
    for (const [key, shortcut] of Object.entries(this.shortcuts)) {
      html += `
        <div class="shortcut-item">
          <kbd>${key}</kbd>
          <span>${shortcut.description}</span>
        </div>
      `;
    }
    
    html += `
          </div>
        </div>
      </div>
    `;
    
    // Retirer le modal existant s'il y en a un
    const existingModal = document.getElementById('helpModal');
    if (existingModal) {
      existingModal.remove();
    }
    
    // Ajouter le nouveau modal
    document.body.insertAdjacentHTML('beforeend', html);
  }

  /**
   * Activer/désactiver les raccourcis
   */
  setEnabled(enabled) {
    this.enabled = enabled;
  }
}

// Export pour utilisation dans d'autres modules
if (typeof module !== 'undefined' && module.exports) {
  module.exports = KeyboardManager;
}
