/* event-modal.js — shared event-detail modal.
 *
 * Used by:
 *   - /sfm (admin Events tab)
 *   - /projects/{p}/nrl/{l}    (project-location Events tab)
 *   - /unit/{id}               (unit-detail SFM Events table)
 *
 * Pages must include partials/event_detail_modal.html in the body
 * before this script is loaded.
 *
 * Public API:
 *   showEventDetail(eventId)
 *       Open the modal and fetch /api/sfm/db/events/{id}/sidecar to
 *       populate the rich BW report fields (peaks, ZC freq, sensor
 *       self-check, device info, etc.) into a tabbed/sectioned view.
 *
 *   closeEventDetailModal()
 *       Close the modal.
 *
 * Notes:
 *   - Fetches sidecar live from SFM via terra-view's /api/sfm proxy.
 *   - Renders gracefully when the sidecar lacks a bw_report block
 *     (older events forwarded before the _ASCII.TXT pairing fix).
 *   - All functions are global on window so inline onclick handlers
 *     can reach them across all three host pages.
 */

(function () {
    const MODAL_ID = 'event-detail-modal';

    function _esc(s) {
        if (s == null) return '';
        return String(s).replace(/&/g, '&amp;')
                        .replace(/</g, '&lt;')
                        .replace(/>/g, '&gt;')
                        .replace(/"/g, '&quot;');
    }

    function _fmt(v, digits = 4, suffix = '') {
        if (v == null || (typeof v === 'number' && Number.isNaN(v))) return '—';
        if (typeof v === 'number') {
            return v.toFixed(digits) + (suffix ? ` ${suffix}` : '');
        }
        return _esc(v) + (suffix ? ` ${suffix}` : '');
    }

    function _ppvClass(v) {
        if (v == null) return 'text-gray-400';
        if (v < 0.5) return 'text-green-600 dark:text-green-400';
        if (v < 2.0) return 'text-amber-600 dark:text-amber-400';
        return 'text-red-600 dark:text-red-400 font-semibold';
    }

    function _kvCard(label, value, options = {}) {
        // Single key-value tile.  `value` is pre-rendered HTML (or text).
        const colorCls = options.colorCls || '';
        const valCls   = `font-mono font-semibold ${colorCls}`;
        return `<div class="bg-gray-50 dark:bg-slate-900/50 rounded-lg p-3">
            <div class="text-xs text-gray-500 dark:text-gray-400 uppercase tracking-wider">${_esc(label)}</div>
            <div class="${valCls} mt-1">${value}</div>
            ${options.sub ? `<div class="text-xs text-gray-500 dark:text-gray-400 mt-1">${options.sub}</div>` : ''}
        </div>`;
    }

    function _deriveRecordType(filename, fallback) {
        // SFM currently hardcodes record_type="Waveform" for every event.
        // The actual type is encoded in the LAST character of the Blastware
        // filename's extension (e.g. "O121LL5E.IS0H" → "H" → Histogram).
        // We derive it client-side until SFM is fixed; if the suffix isn't
        // a known code we fall back to whatever SFM reported.
        if (!filename) return fallback || '—';
        const dotIdx = filename.lastIndexOf('.');
        if (dotIdx < 0 || dotIdx === filename.length - 1) return fallback || '—';
        const ext = filename.slice(dotIdx + 1);
        const lastChar = ext.slice(-1).toUpperCase();
        const typeMap = {
            'H': 'Histogram',
            'W': 'Waveform',
            'M': 'Manual',
            'E': 'Event',
            'C': 'Combo',
        };
        return typeMap[lastChar] || (fallback || '—');
    }

    function _sectionHeader(title, sub) {
        return `<h4 class="text-xs font-semibold text-gray-500 dark:text-gray-400 uppercase tracking-wider mb-3 mt-5 first:mt-0">
            ${_esc(title)}${sub ? ` <span class="text-xs text-gray-400 normal-case font-normal ml-2">${_esc(sub)}</span>` : ''}
        </h4>`;
    }

    // ── Section renderers ────────────────────────────────────────────

    function _renderEventHeader(s) {
        const ev = s.event || {};
        const bw = s.blastware || {};
        const ts = ev.timestamp ? ev.timestamp.replace('T', ' ').slice(0, 19) : '—';
        const recType = _deriveRecordType(bw.filename || ev.blastware_filename, ev.record_type);
        return `<div class="grid grid-cols-1 sm:grid-cols-3 gap-x-6 gap-y-2 text-sm">
            <div><span class="text-gray-500">Serial</span> <span class="font-mono font-semibold text-seismo-orange ml-1">${_esc(ev.serial)}</span></div>
            <div><span class="text-gray-500">Timestamp</span> <span class="font-medium ml-1">${ts}</span></div>
            <div><span class="text-gray-500">Record Type</span> <span class="font-medium ml-1">${_esc(recType)}</span></div>
            <div><span class="text-gray-500">Sample Rate</span> <span class="font-medium ml-1">${ev.sample_rate ?? '—'} sps</span></div>
            <div><span class="text-gray-500">Rec Time</span> <span class="font-medium ml-1">${ev.rectime_seconds != null ? ev.rectime_seconds + ' s' : '—'}</span></div>
            <div><span class="text-gray-500">Waveform Key</span> <span class="font-mono text-xs ml-1">${_esc(ev.waveform_key || '—')}</span></div>
        </div>`;
    }

    function _renderUserNotes(s) {
        // The "user notes" metadata the operator typed into the BW device.
        // These are the strings the future metadata-driven parser will use.
        // NOTE: SFM's sidecar JSON still names this block `project_info` —
        // we render it as "User Notes" (the actual BW term) but read the
        // field by its SFM-API name.  Rename in SFM is a future cleanup.
        const p = s.project_info || {};
        return `<div class="grid grid-cols-1 sm:grid-cols-2 gap-x-6 gap-y-2 text-sm">
            <div><span class="text-gray-500">Project</span> <span class="font-medium ml-1">${_esc(p.project || '—')}</span></div>
            <div><span class="text-gray-500">Client</span> <span class="font-medium ml-1">${_esc(p.client || '—')}</span></div>
            <div><span class="text-gray-500">Operator</span> <span class="font-medium ml-1">${_esc(p.operator || '—')}</span></div>
            <div><span class="text-gray-500">Sensor Location</span> <span class="font-medium ml-1">${_esc(p.sensor_location || '—')}</span></div>
        </div>
        <p class="text-xs text-gray-500 dark:text-gray-400 mt-2 italic">
            Values are as typed into the seismograph at session start — not the terra-view project/location assignment.
        </p>`;
    }

    function _renderPeakValues(s) {
        // Prefer bw_report.peaks for richer per-channel data; fall back to peak_values.
        const bwPeaks = (s.bw_report && s.bw_report.peaks) || null;
        const pv = s.peak_values || {};

        const tran  = bwPeaks ? bwPeaks.tran?.ppv_ips : pv.transverse;
        const vert  = bwPeaks ? bwPeaks.vert?.ppv_ips : pv.vertical;
        const lng   = bwPeaks ? bwPeaks.long?.ppv_ips : pv.longitudinal;
        const pvs   = bwPeaks ? bwPeaks.vector_sum?.ips : pv.vector_sum;
        const pvsAt = bwPeaks ? bwPeaks.vector_sum?.time_s : null;

        return `<div class="grid grid-cols-2 sm:grid-cols-4 gap-3">
            ${_kvCard('Transverse', `<span class="${_ppvClass(tran)}">${_fmt(tran, 4)}</span>`, { sub: 'in/s' })}
            ${_kvCard('Vertical',   `<span class="${_ppvClass(vert)}">${_fmt(vert, 4)}</span>`, { sub: 'in/s' })}
            ${_kvCard('Longitudinal', `<span class="${_ppvClass(lng)}">${_fmt(lng, 4)}</span>`, { sub: 'in/s' })}
            ${_kvCard('Peak Vector Sum', `<span class="${_ppvClass(pvs)} text-base">${_fmt(pvs, 4)}</span>`, {
                sub: pvsAt != null ? `in/s @ t=${_fmt(pvsAt, 2)}s` : 'in/s',
            })}
        </div>`;
    }

    function _renderMic(s) {
        // Operators only care about dB(L); PSI tile was dropped 2026-05.
        // We still render the row if any mic data is present so ZC freq /
        // time-of-peak stay visible even when bw_report.mic is missing.
        const mic = (s.bw_report && s.bw_report.mic) || null;
        const pv = s.peak_values || {};

        if (!mic && pv.mic_psi == null) return '';

        const dbl  = mic?.pspl_dbl;
        const zcHz = mic?.zc_freq_hz;
        const tPk  = mic?.time_of_peak_s;
        const wt   = mic?.weighting;

        return `<div class="grid grid-cols-1 sm:grid-cols-3 gap-3">
            ${_kvCard('Peak Mic dB(L)', _fmt(dbl, 1), { sub: wt || '' })}
            ${_kvCard('ZC Frequency', _fmt(zcHz, 1, 'Hz'))}
            ${_kvCard('Time of Peak', tPk != null ? _fmt(tPk, 2, 's') : '—')}
        </div>`;
    }

    function _sensorRow(label, ch) {
        if (!ch) {
            return `<tr><td class="px-3 py-2 text-sm font-medium">${_esc(label)}</td>
                <td class="px-3 py-2 text-sm text-gray-400" colspan="3">—</td></tr>`;
        }
        const result = ch.result || '—';
        const resultCls = result === 'Passed'
            ? 'text-green-600 dark:text-green-400'
            : (result === 'Failed' ? 'text-red-600 dark:text-red-400 font-semibold' : 'text-gray-500');

        // Geo channels have freq + ratio; mic has freq + amplitude.
        const rightCol = (ch.amplitude_mv != null)
            ? `<td class="px-3 py-2 text-sm font-mono">${_fmt(ch.amplitude_mv, 1, 'mV')}</td>`
            : `<td class="px-3 py-2 text-sm font-mono">${ch.ratio != null ? ch.ratio.toFixed(1) + ' ratio' : '—'}</td>`;

        return `<tr>
            <td class="px-3 py-2 text-sm font-medium">${_esc(label)}</td>
            <td class="px-3 py-2 text-sm font-mono">${_fmt(ch.freq_hz, 1, 'Hz')}</td>
            ${rightCol}
            <td class="px-3 py-2 text-sm ${resultCls}">${_esc(result)}</td>
        </tr>`;
    }

    function _renderSensorCheck(s) {
        const sc = s.bw_report && s.bw_report.sensor_check;
        if (!sc) return '';
        return `<table class="w-full text-left rounded overflow-hidden border border-gray-200 dark:border-gray-700">
            <thead class="bg-gray-50 dark:bg-slate-700">
                <tr>
                    <th class="px-3 py-2 text-xs font-medium text-gray-600 dark:text-gray-400 uppercase">Channel</th>
                    <th class="px-3 py-2 text-xs font-medium text-gray-600 dark:text-gray-400 uppercase">Frequency</th>
                    <th class="px-3 py-2 text-xs font-medium text-gray-600 dark:text-gray-400 uppercase">Amplitude/Ratio</th>
                    <th class="px-3 py-2 text-xs font-medium text-gray-600 dark:text-gray-400 uppercase">Result</th>
                </tr>
            </thead>
            <tbody class="divide-y divide-gray-200 dark:divide-gray-700 bg-white dark:bg-slate-800">
                ${_sensorRow('Transverse',   sc.tran)}
                ${_sensorRow('Vertical',     sc.vert)}
                ${_sensorRow('Longitudinal', sc.long)}
                ${_sensorRow('Microphone',   sc.mic)}
            </tbody>
        </table>`;
    }

    function _renderDeviceMetadata(s) {
        const bw  = s.bw_report || {};
        const dev = bw.device || {};
        const rec = bw.recording || {};
        return `<div class="grid grid-cols-2 sm:grid-cols-3 gap-x-6 gap-y-2 text-sm">
            <div><span class="text-gray-500">Firmware</span> <span class="font-mono text-xs ml-1">${_esc(bw.version || '—')}</span></div>
            <div><span class="text-gray-500">Battery</span> <span class="font-medium ml-1">${dev.battery_volts != null ? dev.battery_volts.toFixed(2) + ' V' : '—'}</span></div>
            <div><span class="text-gray-500">Calibrated</span> <span class="font-medium ml-1">${_esc(dev.calibration_date || '—')}${dev.calibration_by ? ' (' + _esc(dev.calibration_by) + ')' : ''}</span></div>
            <div><span class="text-gray-500">Geo Range</span> <span class="font-medium ml-1">${rec.geo_range_ips != null ? rec.geo_range_ips + ' in/s' : '—'}</span></div>
            <div><span class="text-gray-500">Stop Mode</span> <span class="font-medium ml-1">${_esc(rec.stop_mode || '—')}</span></div>
            <div><span class="text-gray-500">Units</span> <span class="font-medium ml-1">${_esc(rec.units || '—')}</span></div>
        </div>`;
    }

    function _renderFileInfo(s, eventId) {
        const bw  = s.blastware || {};
        const src = s.source || {};
        const sizeKb = bw.filesize ? (bw.filesize / 1024).toFixed(1) : null;
        const canDownloadBinary = !!(bw.available && bw.filename && eventId);

        const downloadButtons = `
            <div class="flex flex-wrap gap-2 mb-4">
                ${canDownloadBinary ? `
                    <a href="/api/sfm/db/events/${encodeURIComponent(eventId)}/blastware_file"
                       download="${_esc(bw.filename)}"
                       class="inline-flex items-center gap-2 px-4 py-2 bg-seismo-orange hover:bg-seismo-navy text-white rounded-lg text-sm font-medium transition-colors">
                        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4"></path>
                        </svg>
                        Download Blastware file
                        <span class="text-xs opacity-80 ml-1">(${_esc(bw.filename)}${sizeKb ? `, ${sizeKb} KB` : ''})</span>
                    </a>
                ` : `
                    <span class="inline-flex items-center gap-2 px-4 py-2 bg-gray-100 dark:bg-gray-800 text-gray-500 dark:text-gray-400 rounded-lg text-sm cursor-not-allowed">
                        <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                            <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4"></path>
                        </svg>
                        Blastware file unavailable
                    </span>
                `}
                <button type="button"
                        onclick="window.toggleEventJsonViewer()"
                        class="inline-flex items-center gap-2 px-3 py-2 border border-gray-300 dark:border-gray-600 hover:bg-gray-50 dark:hover:bg-gray-700 text-gray-700 dark:text-gray-300 rounded-lg text-sm transition-colors">
                    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 20l4-16m4 4l4 4-4 4M6 16l-4-4 4-4"></path>
                    </svg>
                    <span id="event-json-toggle-label">View JSON</span>
                </button>
                <a href="/api/sfm/db/events/${encodeURIComponent(eventId)}/sidecar"
                   download="${_esc((bw.filename || 'event') + '.sfm.json')}"
                   class="inline-flex items-center gap-2 px-3 py-2 border border-gray-300 dark:border-gray-600 hover:bg-gray-50 dark:hover:bg-gray-700 text-gray-700 dark:text-gray-300 rounded-lg text-sm transition-colors">
                    <svg class="w-4 h-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z"></path>
                    </svg>
                    Download sidecar JSON
                </a>
            </div>
            <div id="event-json-viewer" class="hidden mb-4">
                <div class="flex items-center justify-between mb-2">
                    <span class="text-xs text-gray-500 dark:text-gray-400 uppercase tracking-wider">Sidecar JSON</span>
                    <button type="button" onclick="window.copyEventJson()"
                            class="text-xs text-seismo-orange hover:text-seismo-navy">
                        <span id="event-json-copy-label">Copy</span>
                    </button>
                </div>
                <pre id="event-json-pre" class="bg-gray-900 dark:bg-black text-gray-200 font-mono text-xs p-4 rounded-lg max-h-96 overflow-auto whitespace-pre">${_esc(JSON.stringify(s, null, 2))}</pre>
            </div>
        `;

        return `${downloadButtons}
        <div class="grid grid-cols-1 sm:grid-cols-2 gap-x-6 gap-y-2 text-sm">
            <div class="sm:col-span-2"><span class="text-gray-500">Blastware file</span> <span class="font-mono text-xs ml-1">${_esc(bw.filename || '—')}</span> ${sizeKb ? `<span class="text-xs text-gray-500 ml-2">(${sizeKb} KB)</span>` : ''}</div>
            <div class="sm:col-span-2"><span class="text-gray-500">SHA-256</span> <span class="font-mono text-xs ml-1 break-all">${_esc(bw.sha256 || '—')}</span></div>
            <div><span class="text-gray-500">Captured at</span> <span class="font-medium ml-1">${_esc(src.captured_at ? src.captured_at.slice(0, 19).replace('T', ' ') : '—')}</span></div>
            <div><span class="text-gray-500">Tool version</span> <span class="font-mono text-xs ml-1">${_esc(src.tool_version || '—')}</span></div>
        </div>`;
    }

    // ── Public API ───────────────────────────────────────────────────

    window.showEventDetail = async function (eventId) {
        const modal = document.getElementById(MODAL_ID);
        if (!modal) {
            console.warn('event-modal: include event_detail_modal.html partial on this page.');
            return;
        }
        modal.classList.remove('hidden');
        document.getElementById(MODAL_ID + '-title').textContent = 'Event Detail';
        document.getElementById(MODAL_ID + '-content').innerHTML = `
            <div class="text-center py-12 text-gray-500 dark:text-gray-400">
                <div class="animate-spin rounded-full h-8 w-8 border-b-2 border-seismo-orange mx-auto mb-3"></div>
                Loading event detail…
            </div>`;

        let s;
        try {
            const r = await fetch(`/api/sfm/db/events/${encodeURIComponent(eventId)}/sidecar`);
            if (!r.ok) {
                throw new Error('HTTP ' + r.status + ' fetching sidecar');
            }
            s = await r.json();
        } catch (e) {
            document.getElementById(MODAL_ID + '-content').innerHTML = `
                <div class="text-center py-8 text-red-500 text-sm">
                    Failed to load event detail: ${_esc(e.message)}
                </div>`;
            return;
        }

        const ev = s.event || {};
        const ts = ev.timestamp ? ev.timestamp.replace('T', ' ').slice(0, 19) : '';
        document.getElementById(MODAL_ID + '-title').textContent =
            `Event — ${ev.serial || '?'} @ ${ts}`;

        const hasReport = !!s.bw_report;
        const reportNote = hasReport
            ? ''
            : `<div class="bg-amber-50 dark:bg-amber-900/20 border border-amber-200 dark:border-amber-800 rounded-lg p-3 text-sm text-amber-800 dark:text-amber-300 mb-4">
                   <strong>No BW ASCII report paired with this event.</strong>
                   Older events forwarded before the watcher's <code class="font-mono text-xs">_ASCII.TXT</code> pairing fix landed lack this data.
                   PPV is still available from the binary event file.
               </div>`;

        document.getElementById(MODAL_ID + '-content').innerHTML = `
            ${reportNote}

            ${_sectionHeader('Event')}
            ${_renderEventHeader(s)}

            ${_sectionHeader('User Notes')}
            ${_renderUserNotes(s)}

            ${_sectionHeader('Peak Particle Velocity')}
            ${_renderPeakValues(s)}

            ${(s.bw_report && (s.bw_report.mic || s.peak_values?.mic_psi != null)) ? `
                ${_sectionHeader('Microphone')}
                ${_renderMic(s)}
            ` : ''}

            ${hasReport ? `
                ${_sectionHeader('Sensor Self-Check')}
                ${_renderSensorCheck(s)}

                ${_sectionHeader('Device & Recording Metadata')}
                ${_renderDeviceMetadata(s)}
            ` : ''}

            ${_sectionHeader('Source File')}
            ${_renderFileInfo(s, eventId)}
        `;
    };

    window.closeEventDetailModal = function () {
        const modal = document.getElementById(MODAL_ID);
        if (modal) modal.classList.add('hidden');
    };

    window.toggleEventJsonViewer = function () {
        const viewer = document.getElementById('event-json-viewer');
        const label = document.getElementById('event-json-toggle-label');
        if (!viewer) return;
        const isHidden = viewer.classList.toggle('hidden');
        if (label) label.textContent = isHidden ? 'View JSON' : 'Hide JSON';
    };

    window.copyEventJson = function () {
        const pre = document.getElementById('event-json-pre');
        const label = document.getElementById('event-json-copy-label');
        if (!pre) return;
        navigator.clipboard.writeText(pre.textContent).then(() => {
            if (label) {
                label.textContent = 'Copied!';
                setTimeout(() => { label.textContent = 'Copy'; }, 1500);
            }
        }).catch(err => {
            console.error('clipboard write failed', err);
            if (label) {
                label.textContent = 'Failed';
                setTimeout(() => { label.textContent = 'Copy'; }, 1500);
            }
        });
    };

    // Close on Escape.
    document.addEventListener('keydown', function (e) {
        if (e.key === 'Escape') window.closeEventDetailModal();
    });
})();
