// timeline.js — v2.1.4
// Reads active Premiere sequence via UXP premierepro DOM API.
// All Premiere DOM methods are synchronous. No redirect:manual (not in UXP).

(function () {
  const Timeline = {};

  function ppro() {
    if (Timeline._ppro) return Timeline._ppro;
    try { Timeline._ppro = require('premierepro'); }
    catch (e) { throw new Error('UXP premierepro unavailable: ' + e.message); }
    return Timeline._ppro;
  }

  // ── Read active sequence ─────────────────────────────────────────
  Timeline.readActiveSequence = async function () {
    const P = ppro();
    const project = P.Project.getActiveProject();               // sync
    if (!project) throw new Error('No active Premiere project');
    const seq = project.getActiveSequence();                    // sync
    if (!seq) throw new Error('No active sequence');

    const name     = seq.name || 'Sequence 1';
    const settings = seq.getSettings();                         // sync
    let frameRate = 29.97;
    try {
      const fr = settings.videoFrameRate;
      if (fr && typeof fr.seconds === 'number' && fr.seconds > 0) frameRate = 1 / fr.seconds;
    } catch (_) {}
    const width  = settings.videoFrameWidth  || 1920;
    const height = settings.videoFrameHeight || 1080;

    const clips      = [];
    const trackCount = seq.getVideoTrackCount();                // sync

    for (let ti = 0; ti < trackCount; ti++) {
      const track = seq.getVideoTrack(ti);                      // sync
      if (!track) continue;
      let items = [];
      try { items = track.getTrackItems(1, false); } catch (_) { continue; }
      if (!items || !items.length) continue;

      for (const clip of items) {
        try {
          const projItem = clip.getProjectItem();               // sync
          if (!projItem) continue;
          let filePath = '';
          try {
            const clipItem = P.ClipProjectItem.cast(projItem);
            filePath = clipItem.getMediaFilePath() || '';       // sync
          } catch (_) {}
          const fileName = clip.getName() || (filePath ? path.basename(filePath) : 'clip');
          const tlIn  = clip.getStartTime().seconds;
          const tlOut = clip.getEndTime().seconds;
          const srcIn = clip.getInPoint().seconds;
          const srcOut = clip.getOutPoint().seconds;
          clips.push({
            fileName, filePath, trackIndex: ti,
            timelineInSec: tlIn, timelineOutSec: tlOut,
            sourceInSec: srcIn, sourceOutSec: srcOut,
            timelineInFrames:  Math.round(tlIn  * frameRate),
            timelineOutFrames: Math.round(tlOut * frameRate),
            sourceInFrames:    Math.round(srcIn  * frameRate),
            sourceOutFrames:   Math.round(srcOut * frameRate),
          });
        } catch (_) {}
      }
    }
    return { sequenceName: name, frameRate, width, height, clips };
  };

  // ── Active sequence info bar ─────────────────────────────────────
  Timeline.refreshSeqBar = async function () {
    try {
      const P = ppro();
      const project = P.Project.getActiveProject();
      if (!project) { UI.setHidden('#seq-info-bar', true); return; }
      const seq = project.getActiveSequence();
      if (!seq)  { UI.setHidden('#seq-info-bar', true); return; }
      const name = seq.name || '';
      if (name) {
        document.getElementById('seq-info-name').textContent = name;
        UI.setHidden('#seq-info-bar', false);
      } else {
        UI.setHidden('#seq-info-bar', true);
      }
    } catch (_) { UI.setHidden('#seq-info-bar', true); }
  };

  // ── FCP XML ──────────────────────────────────────────────────────
  Timeline.generateFcpXml = function (timelineData) {
    const seqName   = UI.escapeXml(timelineData.sequenceName || 'Sequence 1');
    const frameRate = timelineData.frameRate || 29.97;
    const width     = timelineData.width     || 1920;
    const height    = timelineData.height    || 1080;
    const clips     = timelineData.clips     || [];
    let totalFrames = 0;
    clips.forEach(c => { if ((c.timelineOutFrames||0) > totalFrames) totalFrames = c.timelineOutFrames; });
    if (totalFrames < 1) totalFrames = 100;
    const duration = UI.timecodeFromFrames(totalFrames, frameRate);
    const frateStr = UI.formatFrameRate(frameRate);
    let xml = '<?xml version="1.0" encoding="UTF-8"?>\n<!DOCTYPE fcpxml>\n<fcpxml version="1.10">\n  <resources>\n';
    xml += '    <format id="r0" frameDuration="' + frateStr + '" width="' + width + '" height="' + height + '"/>\n';
    const seen = {}; let rid = 1;
    clips.forEach(clip => {
      const key = clip.filePath || clip.fileName || 'c' + rid;
      if (!seen[key]) {
        seen[key] = 'r' + rid;
        const srcDur = UI.timecodeFromFrames(Math.max(1,(clip.sourceOutFrames||100)-(clip.sourceInFrames||0)), frameRate);
        xml += '    <asset id="r' + rid + '" name="' + UI.escapeXml(clip.fileName||'Clip') + '" src="' + UI.escapeXml(clip.filePath||'') + '" duration="' + srcDur + '" start="0s" format="r0"/>\n';
        rid++;
      }
    });
    xml += '  </resources>\n  <library>\n    <event name="Conform Export">\n      <project name="' + seqName + '">\n        <sequence duration="' + duration + '" format="r0">\n          <spine>\n';
    clips.forEach(clip => {
      const resId = seen[clip.filePath || clip.fileName || 'x'] || 'r1';
      const off   = UI.timecodeFromFrames(clip.timelineInFrames||0, frameRate);
      const dur   = UI.timecodeFromFrames(Math.max(1,(clip.timelineOutFrames||1)-(clip.timelineInFrames||0)), frameRate);
      const srcIn = UI.timecodeFromFrames(clip.sourceInFrames||0, frameRate);
      xml += '            <clip name="' + UI.escapeXml(clip.fileName||'Clip') + '" offset="' + off + '" duration="' + dur + '" start="' + srcIn + '">\n              <asset-clip ref="' + resId + '"/>\n            </clip>\n';
    });
    xml += '          </spine>\n        </sequence>\n      </project>\n    </event>\n  </library>\n</fcpxml>';
    return xml;
  };

  // ── Push Timeline to MAM ─────────────────────────────────────────
  Timeline.pushToMAM = async function (seqName, projectId, timelineData) {
    const resolved = Library.resolveClipsToAssets(timelineData.clips || []);
    const matched  = resolved.filter(c => c.asset_id);
    if (!matched.length) throw new Error('No clips matched MAM assets — import proxies first');
    const seqs = await API.listSequences(projectId);
    let seqId;
    const existing = seqs.find(s => s.name === seqName);
    if (existing) {
      await API.updateSequence(existing.id, { frame_rate: timelineData.frameRate, width: timelineData.width, height: timelineData.height });
      seqId = existing.id;
    } else {
      const created = await API.createSequence(projectId, seqName, timelineData.frameRate, timelineData.width, timelineData.height);
      seqId = created.id;
    }
    await API.pushClips(seqId, matched.map(c => ({
      asset_id: c.asset_id, track: c.trackIndex,
      timeline_in_frames: c.timelineInFrames, timeline_out_frames: c.timelineOutFrames,
      source_in_frames: c.sourceInFrames, source_out_frames: c.sourceOutFrames,
    })));
    return { seqId, matched: matched.length, skipped: resolved.length - matched.length };
  };

  // ── Conform ──────────────────────────────────────────────────────
  Timeline.startConform = async function (projectId, seqName, timelineData, opts) {
    const { seqId } = await Timeline.pushToMAM(seqName, projectId, timelineData);
    const resMap = { '1080p':[1920,1080], '720p':[1280,720], 'uhd':[3840,2160], 'source':[0,0] };
    const [w, h] = resMap[opts.resolution] || [1920,1080];
    const job = await API.startConform(seqId, { codec: opts.codec, quality: opts.quality, width: w||undefined, height: h||undefined, audio: opts.audio, fcp_xml: Timeline.generateFcpXml(timelineData) });
    return job.jobId || job.id;
  };

  Timeline.pollConform = function (jobId, onProgress, onDone) {
    const timer = setInterval(async () => {
      try {
        const job = await API.getJob(jobId);
        onProgress(job.progress || 0, job.status);
        if (job.status === 'completed' || job.status === 'failed') { clearInterval(timer); onDone(job); }
      } catch (_) {}
    }, 2000);
    return timer;
  };

  // ── Batch Hi-Res Relink ──────────────────────────────────────────
  Timeline.batchRelink = async function (selectedClips) {
    const P = ppro();
    const project = P.Project.getActiveProject();               // sync
    if (!project) throw new Error('No active Premiere project');
    const results = { succeeded: 0, failed: 0, errors: [] };

    for (const clip of selectedClips) {
      if (!clip.asset_id) continue;
      try {
        UI.showProgress('Fetching hi-res for ' + clip.fileName + '…', 20);
        const info     = await API.getHiresInfo(clip.asset_id);
        const safeName = UI.sanitizeFilename(info.filename || clip.fileName + '.' + (info.ext || 'mxf'));
        const dest     = await Import._tempPath(safeName);

        UI.showProgress('Downloading ' + safeName + '…', 30);
        // S3 presigned URL — use requestExternal (no auth header, no redirect:manual)
        const r = await API.requestExternal(info.url);
        if (!r.ok) throw new Error('Download HTTP ' + r.status);

        UI.showProgress('Writing…', 60);
        const buf = await r.arrayBuffer();
        await Import._writeBuffer(dest, buf);

        UI.showProgress('Relinking ' + clip.fileName + '…', 85);
        await Timeline._relinkInProject(project, clip.filePath, dest);
        results.succeeded++;
      } catch (e) {
        results.failed++;
        results.errors.push(clip.fileName + ': ' + e.message);
      }
    }
    return results;
  };

  // Walk project items and relink via ClipProjectItem.changeMediaFilePath()
  Timeline._relinkInProject = async function (project, oldPath, newPath) {
    const P    = ppro();
    const root = project.getRootItem();                         // sync (FolderItem)
    let count  = 0;

    function walkSync(folderItem) {
      let children = [];
      try { if (typeof folderItem.getItems === 'function') children = folderItem.getItems() || []; } catch (_) {}
      for (const item of children) {
        try {
          const clipItem = P.ClipProjectItem.cast(item);
          const mp = clipItem.getMediaFilePath();
          if (mp && mp === oldPath) { clipItem.changeMediaFilePath(newPath, false); count++; }
        } catch (_) {
          try { walkSync(item); } catch (__) {}
        }
      }
    }
    walkSync(root);

    // Fallback: findItemsMatchingMediaPath
    if (count === 0) {
      try {
        const matches = P.ClipProjectItem.cast(root).findItemsMatchingMediaPath(oldPath, true);
        for (const item of (matches || [])) {
          try { P.ClipProjectItem.cast(item).changeMediaFilePath(newPath, false); count++; } catch (_) {}
        }
      } catch (_) {}
    }

    if (count === 0) throw new Error('No matching clips found for: ' + (oldPath || 'unknown'));
    return count;
  };

  window.Timeline = Timeline;
})();