import * as Utils from "./utils.js";
import type {
  ManifestLoadedData,
  LevelUpdatedData,
  AudioTrackLoadedData,
} from "hls.js";
import { Core, Segment, StreamRegistration } from "p2p-media-loader-core";
import {
  getAudioStreamProperties,
  getVideoStreamProperties,
} from "./stream-properties.js";

export class SegmentManager {
  core: Core;

  constructor(core: Core) {
    this.core = core;
  }

  processMainManifest(data: ManifestLoadedData) {
    const { levels, audioTracks } = data;
    // in the case of audio only stream it is stored in levels

    for (const level of levels) {
      const { url } = level;
      this.addStream({
        runtimeId: Array.isArray(url) ? (url as string[])[0] : url,
        type: "main",
        properties: getVideoStreamProperties(level),
      });
    }

    for (const track of audioTracks) {
      const { url } = track;
      this.addStream({
        runtimeId: Array.isArray(url) ? (url as string[])[0] : url,
        type: "secondary",
        properties: getAudioStreamProperties(track),
      });
    }
  }

  private addStream(stream: StreamRegistration) {
    // Registration never throws: the core reports failures via its
    // onStreamRegistrationError event, and a failed stream's segments load
    // through the default hls.js loader without P2P.
    this.core.addStreamIfNoneExists(stream);
  }

  updatePlaylist(data: LevelUpdatedData | AudioTrackLoadedData) {
    const {
      details: { url, fragments, live },
    } = data;

    const registeredSegmentIds = this.core.getStreamSegmentRuntimeIds(url);
    if (!registeredSegmentIds) return;

    const segmentToRemoveIds = new Set(registeredSegmentIds);
    const newSegments: Segment[] = [];
    fragments.forEach((fragment, index) => {
      const {
        url: responseUrl,
        byteRange: fragByteRange,
        sn,
        start: startTime,
        end: endTime,
      } = fragment;

      const [start, end] = fragByteRange;
      const byteRange = Utils.getByteRange(
        start,
        end !== undefined ? end - 1 : undefined,
      );
      const runtimeId = Utils.getSegmentRuntimeId(responseUrl, byteRange);
      segmentToRemoveIds.delete(runtimeId);

      if (registeredSegmentIds.has(runtimeId)) return;
      newSegments.push({
        runtimeId,
        url: responseUrl,
        externalId: live ? sn : index,
        byteRange,
        startTime,
        endTime,
      });
    });

    if (!newSegments.length && !segmentToRemoveIds.size) return;
    this.core.updateStream(url, newSegments, segmentToRemoveIds.values());
  }
}