// Jotihunt API Integration Script
// This script fetches real-time data from the Jotihunt API and updates the documentation

// Flag to track if we've already updated the note
let noteUpdatedSuccessfully = false;

// Define the update function in the global scope so it can be accessed from exported functions
const fetchSubscriptionData = async () => {
  try {
    const response = await fetch('https://jotihunt.nl/api/2.0/subscriptions');
    if (!response.ok) {
      throw new Error(`API request failed with status: ${response.status}`);
    }
    
    const data = await response.json();
    return data;
  } catch (error) {
    console.error('Error fetching Jotihunt subscription data:', error);
    return null;
  }
};

// Function to update the competing groups note - defined in global scope
const updateCompetingGroupsNote = async () => {
  // Skip if we've already successfully updated the note
  if (noteUpdatedSuccessfully) {
    return;
  }
  
  // Get data from the API
  const subscriptionData = await fetchSubscriptionData();
  
  // Find the note element using multiple selector strategies
  let noteElement = null;
  
  // Strategy 1: Find by ID
  noteElement = document.getElementById('groups_compeeting');
  
  // Strategy 2: Find by attribute selector for ID
  if (!noteElement) {
    noteElement = document.querySelector('[id="groups_compeeting"]');
  }
  
  // Strategy 3: Find by text content in Note-like elements
  if (!noteElement) {
    const allNotes = document.querySelectorAll('div[class*="Note"], div[class*="note"], [data-component="Note"], [class*="admonition"], [class*="callout"]');
    for (const note of allNotes) {
      if (note.textContent.includes('Total groups competing') || 
          note.textContent.includes('Total groups compeeting')) {
        noteElement = note;
        break;
      }
    }
  }
  
  // Strategy 4: Find ANY element with the specific text content
  if (!noteElement) {
    const treeWalker = document.createTreeWalker(
      document.body,
      NodeFilter.SHOW_TEXT,
      {
        acceptNode: function(node) {
          return (node.textContent.includes('Total groups competing') || 
                 node.textContent.includes('Total groups compeeting')) ? 
                 NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP;
        }
      }
    );

    let textNode;
    while ((textNode = treeWalker.nextNode()) && !noteElement) {
      noteElement = textNode.parentElement;
      // Travel up a few levels to try to find the container element
      for (let i = 0; i < 4 && noteElement; i++) {
        if (noteElement.tagName === 'DIV' || 
            noteElement.tagName === 'ASIDE' || 
            noteElement.tagName === 'SECTION') {
          break;
        }
        noteElement = noteElement.parentElement;
      }
    }
  }
  
  // Strategy 5: Check for elements with data attributes that might indicate a Note component
  if (!noteElement) {
    const dataElements = document.querySelectorAll('[data-note], [data-type="note"], [data-tip="note"], [data-kind="note"]');
    for (const element of dataElements) {
      if (element.textContent.includes('Total groups') || 
          element.textContent.includes('competing')) {
        noteElement = element;
        break;
      }
    }
  }
    // Enable debug mode
  const DEBUG = true;
  
  if (noteElement) {
    console.log('Note element found:', DEBUG ? noteElement : noteElement.tagName);
    
    // Log element details in debug mode
    if (DEBUG) {
      console.log('Element tag:', noteElement.tagName);
      console.log('Element classes:', noteElement.className);
      console.log('Element HTML:', noteElement.outerHTML);
    }
    
    // If we successfully got data from the API
    if (subscriptionData && subscriptionData.data) {
      // Count the number of groups
      const groupCount = subscriptionData.data.length;
      
      // Get current year
      const currentYear = new Date().getFullYear();
      
      try {        // Update the note content with real data
        noteElement.innerHTML = `Total groups competing <code>${groupCount}</code> (<code>${currentYear}</code>)`;
        console.log(`Updated competing groups count to ${groupCount} for year ${currentYear}`);
        // Mark as successfully updated
        noteUpdatedSuccessfully = true;
      } catch (e) {
        console.error('Failed to update innerHTML:', e);
        
        // Try textContent as a fallback
        try {          noteElement.textContent = `Total groups competing ${groupCount} (${currentYear})`;
          console.log('Fallback to textContent update succeeded');
          // Mark as successfully updated
          noteUpdatedSuccessfully = true;
        } catch (e2) {
          console.error('Failed to update textContent too:', e2);
        }
      }
    } else {
      // Get current year
      const currentYear = new Date().getFullYear();
      
      try {        // If API failed, show a fallback message
        noteElement.innerHTML = `Total groups competing <code>Unknown</code> (<code>${currentYear}</code>)`;
        console.log('Using fallback data for competing groups count');
        // Mark as successfully updated even with fallback data
        noteUpdatedSuccessfully = true;
      } catch (e) {
        console.error('Failed to update innerHTML for fallback:', e);
        
        // Try textContent as a fallback
        try {          noteElement.textContent = `Total groups competing Unknown (${currentYear})`;
          console.log('Fallback to textContent update succeeded');
          // Mark as successfully updated even with fallback method
          noteUpdatedSuccessfully = true;
        } catch (e2) {
          console.error('Failed to update textContent too:', e2);
        }
      }
    }
  } else {
    console.warn('Note element not found! Could not update competing groups information');
    
    // Log all potential elements that might be our target in debug mode
    if (DEBUG) {
      console.log('---- Debug: Searching for potential Note elements ----');
      
      // Look for elements with text containing "group"
      const potentialElements = [];
      const treeWalker = document.createTreeWalker(
        document.body,
        NodeFilter.SHOW_TEXT,
        { acceptNode: node => node.textContent.includes('group') ? NodeFilter.FILTER_ACCEPT : NodeFilter.FILTER_SKIP }
      );
      
      let textNode;
      while (textNode = treeWalker.nextNode()) {
        potentialElements.push({
          text: textNode.textContent.trim(),
          parentTag: textNode.parentElement?.tagName,
          parentHtml: textNode.parentElement?.outerHTML.substring(0, 100) + '...'
        });
      }
      
      console.log('Found', potentialElements.length, 'elements containing "group"');
      console.log('Sample elements:', potentialElements.slice(0, 5));
    }
  }
};

// Initialize everything with an IIFE (Immediately Invoked Function Expression)
(function initJotihuntUpdater() {
  // Define the check and update function
  const checkAndUpdatePage = () => {
    // Check for the introduction page
    if (window.location.pathname.includes('/api-reference/jotihunt/introduction') ||
        window.location.pathname.includes('/jotihunt') ||
        window.location.pathname === '/' ||
        window.location.pathname === '') {
      updateCompetingGroupsNote();
    }
  };

  // Make the function available globally
  window.updateCompetingGroupsNote = updateCompetingGroupsNote;
  window.checkAndUpdatePage = checkAndUpdatePage;
  
  // Try to run immediately
  try {
    checkAndUpdatePage();
  } catch (e) {
    console.warn('Initial check failed:', e);
  }
  
  // Add event listeners for different navigation events
  window.addEventListener('popstate', checkAndUpdatePage);
  window.addEventListener('hashchange', checkAndUpdatePage);
  try {
    window.addEventListener('pushstate', checkAndUpdatePage);
    window.addEventListener('replacestate', checkAndUpdatePage);
  } catch (e) {
    // Silent fail for unsupported events
  }  // Set up retries with increasing delays to catch delayed DOM rendering
  // Limited number of attempts to avoid infinite updates
  const retryTimes = [100, 500, 1000, 2000, 5000, 7000, 10000, 15000];
  retryTimes.forEach(time => {
    setTimeout(() => {
      // Only try again if we haven't succeeded yet
      if (!noteUpdatedSuccessfully) {
        checkAndUpdatePage();
      }
    }, time);
  });
  
  // Set up a mutation observer to watch for the note being added to the DOM
  // but stop observing once we've successfully updated
  try {
    if (window.MutationObserver) {
      const observer = new MutationObserver(function(mutations) {
        // Don't process mutations if we've already updated successfully
        if (noteUpdatedSuccessfully) {
          observer.disconnect();
          return;
        }
        
        mutations.forEach(function(mutation) {
          if (mutation.type === 'childList' && mutation.addedNodes.length > 0) {
            // Check if our note element was added
            for (let node of mutation.addedNodes) {
              if (node.nodeType === Node.ELEMENT_NODE) {
                if (node.id === 'groups_compeeting' || 
                    (node.querySelector && node.querySelector('[id="groups_compeeting"]')) ||
                    (node.textContent && (node.textContent.includes('Total groups competing') || 
                                        node.textContent.includes('Total groups compeeting')))) {
                  updateCompetingGroupsNote();
                  // If update was successful, disconnect the observer
                  if (noteUpdatedSuccessfully) {
                    observer.disconnect();
                  }
                  break;
                }
              }
            }
          }
        });
      });
      
      // Start observing once the body exists
      if (document.body) {
        observer.observe(document.body, { 
          childList: true, 
          subtree: true 
        });
      } else {
        // If body doesn't exist yet, wait for it
        const bodyCheckInterval = setInterval(() => {
          if (document.body) {
            // Only start observing if we haven't updated successfully yet
            if (!noteUpdatedSuccessfully) {
              observer.observe(document.body, { 
                childList: true, 
                subtree: true 
              });
            }
            clearInterval(bodyCheckInterval);
          }
        }, 50);
      }
    }
  } catch (e) {
    // Silent fail
  }
  
  // Also try to run when window loads completely, but only if not already updated
  window.addEventListener('load', function() {
    if (!noteUpdatedSuccessfully) {
      checkAndUpdatePage();
    }
  });
})();

// Make the refresh function available globally instead of using export
window.refreshJotihuntData = (forceUpdate = false) => {
  // Allow forcing an update even if we've already updated once before
  if (forceUpdate) {
    // Temporarily reset the flag
    noteUpdatedSuccessfully = false;
  }
  
  if (typeof updateCompetingGroupsNote === 'function') {
    updateCompetingGroupsNote();
  } else if (typeof window.updateCompetingGroupsNote === 'function') {
    window.updateCompetingGroupsNote();
  } else {
    console.error('updateCompetingGroupsNote function not available');
  }
};

API reference for the n8n workflow automation platform

n8n API Documentation

SilkePilon

Welcome to Silke Pilon's API Documentation Collection

API Documentation Hub

About Me

Learn how to integrate the Jotihunt API with n8n for automated workflows

Automating Jotihunt with n8n

Learn how to integrate Jotihunt with Discord using either a full bot or simple webhooks

Discord Integration for Jotihunt

Learn how to forward Jotihunt Telegram messages to Discord or WhatsApp

Telegram Message Forwarder for Jotihunt

API reference for the Jotihunt scouting game platform

Jotihunt API Documentation

Returns all scouting group subscriptions in the system

Returns all areas and their current status

Get leaderboard

Websocket Channel

RSS Feed

Development endpoint for generating a formatted summary report based on the provided support items and comments

Generate a summary report (Development)

Generate a formatted summary report based on the provided support items and comments

API Documentation

n8n Testing Endpoints

n8n Production Endpoints

n8n API Documentation