(function ($) {
  $.fn.countTo = function (options) {
    options = options || {};
    
    return $(this).each(function () {
      // set options for current element
      var settings = $.extend({}, $.fn.countTo.defaults, {
        from:            $(this).data('from'),
        to:              $(this).data('to'),
        speed:           $(this).data('speed'),
        refreshInterval: $(this).data('refresh-interval'),
        decimals:        $(this).data('decimals')
      }, options);
      
      // how many times to update the value, and how much to increment the value on each update
      var loops = Math.ceil(settings.speed / settings.refreshInterval),
        increment = (settings.to - settings.from) / loops;
      
      // references & variables that will change with each update
      var self = this,
        $self = $(this),
        loopCount = 0,
        value = settings.from,
        data = $self.data('countTo') || {};
      
      $self.data('countTo', data);
      
      // if an existing interval can be found, clear it first
      if (data.interval) {
        clearInterval(data.interval);
      }
      data.interval = setInterval(updateTimer, settings.refreshInterval);
      
      // initialize the element with the starting value
      render(value);
      
      function updateTimer() {
        value += increment;
        loopCount++;
        
        render(value);
        
        if (typeof(settings.onUpdate) == 'function') {
          settings.onUpdate.call(self, value);
        }
        
        if (loopCount >= loops) {
          // remove the interval
          $self.removeData('countTo');
          clearInterval(data.interval);
          value = settings.to;
          
          if (typeof(settings.onComplete) == 'function') {
            settings.onComplete.call(self, value);
          }
        }
      }
      
      function render(value) {
        var formattedValue = settings.formatter.call(self, value, settings);
        $self.html(formattedValue);
      }
    });
  };
  
  $.fn.countTo.defaults = {
    from: 0,               // the number the element should start at
    to: 0,                 // the number the element should end at
    speed: 1000,           // how long it should take to count between the target numbers
    refreshInterval: 100,  // how often the element should be updated
    decimals: 0,           // the number of decimal places to show
    formatter: formatter,  // handler for formatting the value before rendering
    onUpdate: null,        // callback method for every time the element is updated
    onComplete: null       // callback method for when the element finishes updating
  };
  
  function formatter(value, settings) {
    return value.toFixed(settings.decimals);
  }
}(jQuery));

jQuery(function ($) {
  // custom formatting example
  $('.count-number').data('countToOptions', {
  formatter: function (value, options) {
    return value.toFixed(options.decimals).replace(/\B(?=(?:\d{3})+(?!\d))/g, ',');
  }
  });
});

document.querySelectorAll(".hamburger").forEach((element) => {
  element.addEventListener("click", (event) => {
    element.classList.toggle("is-active");
  });
});


document.addEventListener('DOMContentLoaded', () => {
    const fontSwitcherButtons = document.querySelectorAll('.btn-fontsize');
    const body = document.body;
    const storageKey = 'selectedFontSize'; // Key for localStorage

    // Function to set the font size
    const setFontSize = (size) => {
        // Remove existing font size classes
        body.classList.remove('font-small', 'font-medium', 'font-large');

        // Add the new font size class
        body.classList.add(`font-${size}`);

        // Update active state of buttons
        fontSwitcherButtons.forEach(button => {
            if (button.dataset.size === size) {
                button.classList.add('active');
            } else {
                button.classList.remove('active');
            }
        });

        // Save the selected font size to localStorage
        localStorage.setItem(storageKey, size);
    };

    // Event listeners for the buttons
    fontSwitcherButtons.forEach(button => {
        button.addEventListener('click', (event) => {
            const size = event.target.dataset.size;
            setFontSize(size);
        });
    });

    // Check localStorage for a previously selected font size on page load
    const storedFontSize = localStorage.getItem(storageKey);
    if (storedFontSize) {
        setFontSize(storedFontSize);
    } else {
        // If no size is stored, set the default (medium)
        setFontSize('medium');
    }
});


function updateTabButton(tab) {
  const $tabs = tab.find('.nav-link');
  const $activeTab = $tabs.filter('.active');
  const activeIndex = $tabs.index($activeTab);
  const totalTabs = $tabs.length;

  // Disable "Previous" button if on the first tab
  if (activeIndex === 0) {
    $('.prev-tab').prop('disabled', true).addClass('btn-disabled');
  } else {
    $('.prev-tab').prop('disabled', false).removeClass('btn-disabled');
  }

  // Disable "Next" button if on the last tab
  if (activeIndex === totalTabs - 1) {
    $('.next-tab').prop('disabled', true).addClass('btn-disabled');
  } else {
    $('.next-tab').prop('disabled', false).removeClass('btn-disabled');
  }
}

function initTab(tab){
  tab.find('.next-tab').on('click', function () {
    const $tabs = tab.find('.nav-link');
    const $activeTab = $tabs.filter('.active');
    const activeIndex = $tabs.index($activeTab);
    const nextIndex = activeIndex + 1;

    if (nextIndex < $tabs.length) {
      $tabs.eq(nextIndex).trigger('click');
    }
  });

  // Handle "Previous" button click
  tab.find('.prev-tab').on('click', function () {
    const $tabs = tab.find('.nav-link');
    const $activeTab = $tabs.filter('.active');
    const activeIndex = $tabs.index($activeTab);
    const prevIndex = activeIndex - 1;

    if (prevIndex >= 0) {
      $tabs.eq(prevIndex).trigger('click');
    }
  });

  tab.find('.nav-link').on('shown.bs.tab', function () {
    updateTabButton(tab);
  });

  updateTabButton(tab);
}