'use strict';

/**
 * SIDE NAVIGATION - JavaScript
 * Gestisce sia vertical che horizontal navigation
 * Supporta keyboard navigation, ESC key, e focus management
 */

// Helper function to find the closest ancestor with a specific tag name
function findAncestor(element, tagName) {
  while (element) {
    if (element.tagName.toLowerCase() === tagName) {
      return element;
    }
    element = element.parentElement;
  }
  return null;
}

class submenuDisclosure {
  constructor(domNode) {
    this.rootNode = domNode;
    this.parentNav = domNode.closest('.rtds-side-navigation');
    this.isHorizontal = this.parentNav?.classList.contains('rtds-side-navigation--horizontal');
    this.controlledNodes = [];
    this.openIndex = null;
    this.useArrowKeys = true;
    
    // Trova tutti i link e toggle button di primo livello
    this.topLevelNodes = [
      ...this.rootNode.querySelectorAll('.rtds-nav-link, .rtds-nav-toggle'),
    ];

    this.init();
  }

  init() {
    this.topLevelNodes.forEach((node) => {
      // Gestisci button + menu
      if (
        node.tagName.toLowerCase() === 'button' &&
        node.hasAttribute('aria-controls')
      ) {
        const menuLiParent = node.closest('li');
        const menu = menuLiParent.querySelector('ul');

        if (menu) {
          // Salva riferimento al menu controllato
          this.controlledNodes.push(menu);

          // Inizializza stato (aperto se current trail, chiuso altrimenti)
          if (menu.querySelector('.is-current') || node.classList.contains('is-current')) {
            node.setAttribute('aria-expanded', 'true');
            this.toggleMenu(menu, true);
          } else {
            node.setAttribute('aria-expanded', 'false');
            this.toggleMenu(menu, false);
          }

          // Attach event listeners
          menu.addEventListener('keydown', this.onMenuKeyDown.bind(this));
          node.addEventListener('click', this.onButtonClick.bind(this));
          node.addEventListener('keydown', this.onButtonKeyDown.bind(this));
        }
      }
      // Gestisci link semplici
      else {
        this.controlledNodes.push(null);
        node.addEventListener('keydown', this.onLinkKeyDown.bind(this));
      }
    });

    // Riferimento al toggle button principale (mobile)
    this.mainMenuToggle = this.parentNav?.querySelector('.rtds-nav-list-toggle');

    // ESC chiude il menu principale su mobile
    this.rootNode.addEventListener('keydown', (event) => {
      if (event.key === 'Escape' && window.innerWidth < 768) {
        if (this.mainMenuToggle?.getAttribute('aria-expanded') === 'true') {
          this.mainMenuToggle.setAttribute('aria-expanded', 'false');
          this.mainMenuToggle.focus();
        }
      }
    });
  }

  // Gestisce navigazione con arrow keys
  controlFocusByKey(keyboardEvent, nodeList, currentIndex) {
    switch (keyboardEvent.key) {
      case 'ArrowUp':
      case 'ArrowLeft':
        keyboardEvent.preventDefault();
        if (currentIndex > -1) {
          var prevIndex = Math.max(0, currentIndex - 1);
          nodeList[prevIndex].focus();
        }
        break;
      case 'ArrowDown':
      case 'ArrowRight':
        keyboardEvent.preventDefault();
        if (currentIndex > -1) {
          var nextIndex = Math.min(nodeList.length - 1, currentIndex + 1);
          nodeList[nextIndex].focus();
        }
        break;
      case 'Home':
        keyboardEvent.preventDefault();
        nodeList[0].focus();
        break;
      case 'End':
        keyboardEvent.preventDefault();
        nodeList[nodeList.length - 1].focus();
        break;
    }
  }

  // Chiude il submenu aperto
  close() {
    this.toggleExpand(this.openIndex, false);
  }

  // Click su toggle button
  onButtonClick(event) {
    var target = event.target;

    if (target.tagName.toLowerCase() !== 'button') {
      var buttonAncestor = findAncestor(target, 'button');
      if (buttonAncestor) {
        buttonAncestor.click();
        return;
      }
    }

    var button = event.currentTarget;
    var buttonIndex = this.topLevelNodes.indexOf(button);
    var buttonExpanded = button.getAttribute('aria-expanded') === 'true';
    this.toggleExpand(buttonIndex, !buttonExpanded);
  }

  // Keyboard events su toggle button
  onButtonKeyDown(event) {
    var targetButtonIndex = this.topLevelNodes.indexOf(document.activeElement);

    if (event.key === 'Escape') {
      this.toggleExpand(this.openIndex, false);
    }
    else if (
      this.useArrowKeys &&
      this.openIndex === targetButtonIndex &&
      event.key === 'ArrowDown'
    ) {
      event.preventDefault();
      this.controlledNodes[this.openIndex].querySelector('a').focus();
    }
    else if (this.useArrowKeys) {
      this.controlFocusByKey(event, this.topLevelNodes, targetButtonIndex);
    }
  }

  // Keyboard events su link semplici
  onLinkKeyDown(event) {
    var targetLinkIndex = this.topLevelNodes.indexOf(document.activeElement);
    if (this.useArrowKeys) {
      this.controlFocusByKey(event, this.topLevelNodes, targetLinkIndex);
    }
  }

  // Keyboard events nel submenu
  onMenuKeyDown(event) {
    if (this.openIndex === null) {
      return;
    }

    var menuLinks = Array.prototype.slice.call(
      this.controlledNodes[this.openIndex].querySelectorAll('a')
    );
    var currentIndex = menuLinks.indexOf(document.activeElement);

    if (event.key === 'Escape') {
      this.topLevelNodes[this.openIndex].focus();
      this.toggleExpand(this.openIndex, false);
    }
    else if (this.useArrowKeys) {
      this.controlFocusByKey(event, menuLinks, currentIndex);
    }
  }

  // Apre/chiude submenu
  toggleExpand(index, expanded) {
    // Chiudi altri submenu aperti
    if (this.openIndex !== index) {
      this.toggleExpand(this.openIndex, false);
    }

    if (this.topLevelNodes[index]) {
      this.openIndex = expanded ? index : null;
      this.topLevelNodes[index].setAttribute('aria-expanded', expanded);
      this.toggleMenu(this.controlledNodes[index], expanded);
    }
  }

  // Mostra/nascondi menu
  toggleMenu(domNode, show) {
    if (domNode) {
      domNode.style.display = show ? 'block' : 'none';
    }
  }

  // Abilita/disabilita arrow keys
  updateKeyControls(useArrowKeys) {
    this.useArrowKeys = useArrowKeys;
  }
}

/* Initialize Disclosure Menus */
window.addEventListener('load', function () {
  // Toggle per mobile menu
  const navListToggle = document.querySelector('.rtds-nav-list-toggle');
  if (navListToggle) {
    navListToggle.addEventListener('click', function() {
      const currentState = this.getAttribute('aria-expanded') === 'true';
      this.setAttribute('aria-expanded', (!currentState).toString());
    });

    // Mantieni menu aperto durante scroll up su mobile
    let lastScrollTop = 0;
    window.addEventListener('scroll', function() {
      const scrollTop = window.pageYOffset || document.documentElement.scrollTop;
      if (scrollTop < lastScrollTop && navListToggle.getAttribute('aria-expanded') === 'true') {
        navListToggle.setAttribute('aria-expanded', 'true');
      }
      lastScrollTop = scrollTop;
    });
  }

  // Inizializza tutti i menu con dropdown
  var dropdownMenus = document.querySelectorAll('.has-nav-dropdown');
  var disclosureMenus = [];

  for (var i = 0; i < dropdownMenus.length; i++) {
    disclosureMenus[i] = new submenuDisclosure(dropdownMenus[i]);
  }

  // Optional: switch per abilitare/disabilitare arrow keys
  var arrowKeySwitch = document.getElementById('arrow-behavior-switch');
  if (arrowKeySwitch) {
    arrowKeySwitch.addEventListener('change', function () {
      var checked = arrowKeySwitch.checked;
      for (var i = 0; i < disclosureMenus.length; i++) {
        disclosureMenus[i].updateKeyControls(checked);
      }
    });
  }
}, false);