/**
 * KAMIS ticker embed client
 * - Safe, independent: targets containers with id passed from shortcode
 * - Uses kamisTickerConfig.endpoint localized by PHP
 *
 * File: wp-content/plugins/kamis-autoupdate/assets/ticker-embed.js
 */

(function () {
  'use strict';

  // Default helpers
  function escapeHtml(s) {
    if (s === null || s === undefined) return '';
    return String(s).replace(/[&<>"']/g, function (m) {
      return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#039;' }[m];
    });
  }

  // Render items into the container
  function renderTicker(container, items) {
    if (!container) return;
    const inner = document.createElement('div');
    inner.className = 'kamis-ticker-inner';
    let html = '';
    // duplicate items for smooth loop
    for (let copy = 0; copy < 2; copy++) {
      for (let i = 0; i < items.length; i++) {
        const it = items[i];
        html += '<div class="kamis-ticker-item">';
        html += '<span class="kamis-ticker-label">' + escapeHtml(it.commodity || '') + '</span>';
        html += '<span class="kamis-ticker-price">' + escapeHtml(it.retail || it.price || '') + '</span>';
        html += '<span class="kamis-ticker-location">📍 ' + escapeHtml(it.market || '') + (it.county ? ', ' + escapeHtml(it.county) : '') + '</span>';
        html += '</div>';
      }
    }
    inner.innerHTML = html;
    // replace existing content
    container.innerHTML = '';
    container.appendChild(inner);
  }

  // Map plugin payload (same format as plugin cache)
  function mapPayloadToItems(payload, limit) {
    if (!payload || !payload.data) return [];
    const data = payload.data;
    const headers = Array.isArray(data.headers) ? data.headers : [];
    const rows = Array.isArray(data.rows) ? data.rows : [];
    const hdrMap = {};
    headers.forEach(function (h, i) { hdrMap[(h || '').toString().toLowerCase().replace(/[^a-z0-9]+/g, '_')] = i; });

    const cand = {
      commodity: ['commodity','product','commodity_name','crop','item'],
      market: ['market','market_name','market_place','location'],
      retail: ['retail','retail_kg','retail_price','price','retail_price_kg','price_kg','wholesale_90kg','wholesale'],
      county: ['county','county_name','region','district','market_county','location']
    };

    const items = [];
    for (let r = 0; r < rows.length && items.length < limit; r++) {
      const row = rows[r];
      if (Array.isArray(row)) {
        // array row -> use hdrMap
        const getByCandidates = function (keys) {
          for (let i = 0; i < keys.length; i++) {
            const idx = hdrMap[keys[i]];
            if (idx !== undefined && row[idx] !== undefined && String(row[idx]).trim() !== '') return row[idx];
          }
          return '';
        };
        items.push({
          commodity: getByCandidates(cand.commodity),
          market: getByCandidates(cand.market),
          retail: getByCandidates(cand.retail),
          county: getByCandidates(cand.county)
        });
      } else {
        // associative
        const pick = function (obj, keys) {
          for (let i = 0; i < keys.length; i++) {
            const k = keys[i];
            if (obj[k] !== undefined && obj[k] !== null && String(obj[k]).trim() !== '') return obj[k];
          }
          return '';
        };
        items.push({
          commodity: pick(row, cand.commodity),
          market: pick(row, cand.market),
          retail: pick(row, cand.retail),
          county: pick(row, cand.county)
        });
      }
    }
    return items;
  }

  // Fetch plugin REST endpoint (primary) and return items array. If REST fails return empty array.
  async function fetchFromRest(limit) {
    if (!window.kamisTickerConfig || !window.kamisTickerConfig.endpoint) return [];
    try {
      const res = await fetch(window.kamisTickerConfig.endpoint, { credentials: 'same-origin' });
      if (!res.ok) throw new Error('REST status ' + res.status);
      const json = await res.json();
      if (!json || json.status === 'no_data' || !json.data) return [];
      return mapPayloadToItems(json, limit);
    } catch (err) {
      console.warn('kamis-ticker: REST fetch failed', err);
      return [];
    }
  }

  // Public initializer used by shortcode inline script
  window.kamisTickerEmbedInit = window.kamisTickerEmbedInit || function (containerId) {
    const container = document.getElementById(containerId);
    if (!container) return;

    const limit = parseInt(container.getAttribute('data-limit')) || 12;
    const refresh = parseInt(container.getAttribute('data-refresh')) || 300;

    // wrapper CSS class - safe namespaced classes only
    container.classList.add('kamis-ticker-container');

    async function refreshOnce() {
      // try REST first
      let items = await fetchFromRest(limit);
      // If no items from REST, try fetching via no-cors fallback (optional): leave empty to avoid cross origin in many cases
      if ((!items || items.length === 0) && window.kamisTickerFallbackUrl) {
        try {
          const proxy = window.kamisTickerFallbackProxy || 'https://api.allorigins.win/raw?url=';
          const res = await fetch(proxy + encodeURIComponent(window.kamisTickerFallbackUrl));
          const html = await res.text();
          // minimal DOM parse to extract simple table rows (best-effort)
          const doc = new DOMParser().parseFromString(html, 'text/html');
          const table = doc.querySelector('table');
          const parsed = [];
          if (table) {
            const rows = table.querySelectorAll('tbody tr');
            for (let i = 0; i < Math.min(limit, rows.length); i++) {
              const cells = rows[i].querySelectorAll('td');
              parsed.push({
                commodity: cells[0] ? cells[0].textContent.trim() : '',
                market: cells[4] ? cells[4].textContent.trim() : '',
                retail: cells[6] ? cells[6].textContent.trim() : '',
                county: cells[8] ? cells[8].textContent.trim() : ''
              });
            }
            items = parsed;
          }
        } catch (err) {
          console.warn('kamis-ticker: fallback parse failed', err);
        }
      }

      if (!items || items.length === 0) {
        // final fallback static message
        items = [ { commodity: 'No data', market: '', retail: '', county: '' } ];
      }
      renderTicker(container, items);
    }

    // initial fetch + schedule
    refreshOnce();
    const timer = setInterval(refreshOnce, Math.max(60, refresh) * 1000);

    // store ref if needed
    if (!window._kamisTickerInstances) window._kamisTickerInstances = {};
    window._kamisTickerInstances[containerId] = { id: containerId, timer: timer };
  };

})();