defmodule Membrane.HTTPAdaptiveStream.HLS do
  @moduledoc """
  `Membrane.HTTPAdaptiveStream.Manifest` implementation for HTTP Live Streaming.

  Currently supports up to one audio and video stream.
  """
  @behaviour Membrane.HTTPAdaptiveStream.Manifest

  use Numbers, overload_operators: true

  alias Membrane.HTTPAdaptiveStream.{BandwidthCalculator, Manifest}
  alias Membrane.HTTPAdaptiveStream.Manifest.{Segment, Track}
  alias Membrane.Time

  @version 7
  @delta_version 9

  @master_playlist_header """
                          #EXTM3U
                          #EXT-X-VERSION:#{@version}
                          #EXT-X-INDEPENDENT-SEGMENTS
                          """
                          |> String.trim()

  @empty_segments Qex.new()
  @default_audio_track_id "audio_default_id"
  @default_audio_track_name "audio_default_name"

  @keep_latest_n_segment_parts 4
  @min_segments_in_delta_playlist 6

  defmodule SegmentAttribute do
    @moduledoc """
    Implementation of `Membrane.HTTPAdaptiveStream.Manifest.SegmentAttribute` behaviour for HTTP Live Streaming
    """
    @behaviour Membrane.HTTPAdaptiveStream.Manifest.SegmentAttribute

    import Membrane.HTTPAdaptiveStream.Manifest.SegmentAttribute

    @impl true
    def serialize(discontinuity(header_name, number)) do
      [
        "#EXT-X-DISCONTINUITY-SEQUENCE:#{number}",
        "#EXT-X-DISCONTINUITY",
        "#EXT-X-MAP:URI=#{header_name}"
      ]
    end

    @impl true
    def serialize({:creation_time, date_time}) do
      [
        "#EXT-X-PROGRAM-DATE-TIME:#{date_time |> DateTime.truncate(:millisecond) |> DateTime.to_iso8601()}"
      ]
    end
  end

  @doc """
  Generates EXTM3U playlist for the given manifest
  """
  @impl true
  def serialize(%Manifest{} = manifest) do
    tracks_by_content =
      manifest.tracks
      |> Map.values()
      |> Enum.group_by(& &1.content_type)

    if length(Map.get(tracks_by_content, :audio, [])) > 1 do
      raise ArgumentError, message: "Multiple audio tracks are not currently supported."
    end

    master_manifest = master_playlist_from_tracks(tracks_by_content, manifest)
    manifest_per_track = playlists_per_track(tracks_by_content)

    %{
      master_manifest: master_manifest,
      manifest_per_track: manifest_per_track
    }
  end

  defp master_playlist_from_tracks(tracks, manifest) do
    master_manifest_name = "#{manifest.name}.m3u8"

    master_playlist =
      case tracks do
        %{muxed: muxed} -> build_master_playlist({nil, muxed})
        %{audio: [audio], video: videos} -> build_master_playlist({audio, videos})
        %{audio: [audio]} -> build_master_playlist({audio, nil})
        %{video: videos} -> build_master_playlist({nil, videos})
      end

    {master_manifest_name, master_playlist}
  end

  defp playlists_per_track(tracks) do
    case tracks do
      %{muxed: tracks} ->
        serialize_tracks(tracks)

      %{audio: audios, video: videos} ->
        serialized_videos = serialize_tracks(videos)
        serialized_audios = serialize_tracks(audios)
        Map.merge(serialized_videos, serialized_audios)

      %{audio: audios} ->
        serialize_tracks(audios)

      %{video: videos} ->
        serialize_tracks(videos)
    end
  end

  defp serialize_tracks(tracks) do
    tracks
    |> Enum.filter(&(&1.segments != @empty_segments))
    |> Enum.reduce(%{}, &add_serialized_track(&2, &1))
  end

  defp add_serialized_track(tracks_map, track) do
    target_duration = calculate_target_duration(track)
    playlist_path = build_media_playlist_path(track)

    case maybe_calculate_delta_params(track, target_duration) do
      {:create_delta, delta_ctx} ->
        serialized_track =
          {playlist_path, serialize_track(track, target_duration, %{delta_ctx | skip_count: 0})}

        delta_path = build_media_playlist_path(track, delta?: true)
        serialized_delta_track = {delta_path, serialize_track(track, target_duration, delta_ctx)}

        tracks_map
        |> Map.put(track.id, serialized_track)
        |> Map.put(:"#{track.id}_delta", serialized_delta_track)

      :dont_create_delta ->
        serialized_track = {playlist_path, serialize_track(track, target_duration)}
        Map.put(tracks_map, track.id, serialized_track)
    end
  end

  defp calculate_target_duration(track) do
    Ratio.ceil(track.segment_duration / Time.second()) |> trunc()
  end

  defp maybe_calculate_delta_params(track, target_duration) do
    min_duration = Time.seconds(@min_segments_in_delta_playlist * target_duration)
    segments = track.segments

    with true <- Track.supports_partial_segments?(track),
         true <- track_supports_delta_creation?(track),
         latest_full_segments <-
           segments
           |> Qex.reverse()
           |> Enum.drop_while(&(&1.type == :partial)),
         {skip_count, skip_duration} <-
           latest_full_segments
           |> Enum.with_index()
           |> Enum.reduce_while(0, fn {segment, idx}, duration ->
             duration = duration + segment.duration

             if duration >= min_duration,
               do: {:halt, {Enum.count(latest_full_segments) - idx - 1, duration}},
               else: {:cont, duration}
           end),
         true <- skip_count > 0 do
      delta_ctx = %{
        skip_count: skip_count,
        skip_duration: Ratio.to_float(skip_duration / Time.second())
      }

      {:create_delta, delta_ctx}
    else
      _any -> :dont_create_delta
    end
  end

  defp track_supports_delta_creation?(track) do
    track.target_window_duration == :infinity
  end

  defp build_media_playlist_path(track, opts \\ [delta?: false])

  defp build_media_playlist_path(%Track{} = track, delta?: true) do
    track.track_name <> "_delta.m3u8"
  end

  defp build_media_playlist_path(%Track{} = track, delta?: false) do
    track.track_name <> ".m3u8"
  end

  defp build_media_playlist_tag(%Track{} = track) do
    case track do
      %Track{content_type: :audio} ->
        """
        #EXT-X-MEDIA:TYPE=AUDIO,NAME="#{@default_audio_track_name}",GROUP-ID="#{@default_audio_track_id}",AUTOSELECT=YES,DEFAULT=YES,URI="#{build_media_playlist_path(track)}"#{serialize_encoding(track)}
        """
        |> String.trim()

      %Track{content_type: type} when type in [:video, :muxed] ->
        """
        #EXT-X-STREAM-INF:#{serialize_bandwidth(track)}#{serialize_resolution(track)}#{serialize_framerate(track)}#{serialize_encoding(track)}
        """
        |> String.trim()
    end
  end

  defp serialize_bandwidth(track) do
    "BANDWIDTH=#{BandwidthCalculator.calculate_max_bandwidth(track)},AVERAGE-BANDWIDTH=#{BandwidthCalculator.calculate_avg_bandwidth(track)}"
  end

  defp serialize_framerate(%Track{max_framerate: framerate}) when is_number(framerate),
    do: ",FRAME-RATE=#{framerate}"

  defp serialize_framerate(_track), do: ""

  defp serialize_resolution(%Track{resolution: {width, height}}) do
    ",RESOLUTION=#{width}x#{height}"
  end

  defp serialize_resolution(_track), do: ""

  defp serialize_encoding(%Track{encoding: %{} = encoding}) do
    codecs_string =
      encoding
      |> Enum.map_join(",", &serialize_codec(&1))
      |> String.trim()

    ",CODECS=\"#{codecs_string}\""
  end

  defp serialize_encoding(%Track{}), do: ""

  defp serialize_codec({:avc1, %{profile: profile, compatibility: compatibility, level: level}}) do
    [profile, compatibility, level]
    |> Enum.map(&Integer.to_string(&1, 16))
    |> Enum.map_join(&String.pad_leading(&1, 2, "0"))
    |> then(&"avc1.#{&1}")
    |> String.downcase()
  end

  defp serialize_codec({:mp4a, %{aot_id: aot_id}}), do: String.downcase("mp4a.40.#{aot_id}")

  defp serialize_codec(_other), do: ""

  defp build_master_playlist(tracks) do
    case tracks do
      {audio, nil} ->
        [@master_playlist_header, build_media_playlist_tag(audio)]
        |> Enum.join("")

      {nil, videos} ->
        [
          @master_playlist_header
          | videos
            |> Enum.filter(&(&1.segments != @empty_segments))
            |> Enum.flat_map(&[build_media_playlist_tag(&1), build_media_playlist_path(&1)])
        ]
        |> Enum.join("\n")

      {audio, videos} ->
        video_tracks =
          videos
          |> Enum.filter(&(&1.segments != @empty_segments))
          |> Enum.flat_map(
            &[
              "#{build_media_playlist_tag(&1)},AUDIO=\"#{@default_audio_track_id}\"",
              build_media_playlist_path(&1)
            ]
          )

        [
          @master_playlist_header,
          build_media_playlist_tag(audio),
          video_tracks
        ]
        |> List.flatten()
        |> Enum.join("\n")
    end
  end

  defp serialize_track(
         %Track{} = track,
         target_duration,
         delta_ctx \\ %{skip_count: 0, skip_duration: 0}
       ) do
    supports_ll_hls? = Track.supports_partial_segments?(track)

    """
    #EXTM3U
    #EXT-X-VERSION:#{if delta_ctx.skip_count > 0, do: @delta_version, else: @version}
    #EXT-X-TARGETDURATION:#{target_duration}
    """ <>
      serialize_ll_hls_tags(track, segments_to_skip_duration: delta_ctx.skip_duration) <>
      """
      #EXT-X-MEDIA-SEQUENCE:#{track.current_seq_num}
      #EXT-X-DISCONTINUITY-SEQUENCE:#{track.current_discontinuity_seq_num}
      #EXT-X-MAP:URI="#{track.header_name}"
      #{serialize_segments(track.segments, supports_ll_hls?: supports_ll_hls?, segments_to_skip_count: delta_ctx.skip_count)}
      #{if track.finished?, do: "#EXT-X-ENDLIST", else: serialize_preload_hint_tag(supports_ll_hls?, track)}
      """
  end

  defp serialize_segments(segments,
         supports_ll_hls?: supports_ll_hls?,
         segments_to_skip_count: segments_to_skip_count
       )
       when segments_to_skip_count > 0 do
    prefix = """
    #EXT-X-SKIP:SKIPPED-SEGMENTS=#{segments_to_skip_count}
    """

    serialized_segments =
      segments
      |> Enum.drop(segments_to_skip_count)
      |> serialize_segments(supports_ll_hls?: supports_ll_hls?, segments_to_skip_count: 0)

    prefix <> serialized_segments
  end

  defp serialize_segments(segments, supports_ll_hls?: supports_ll_hls?, segments_to_skip_count: 0) do
    segments
    |> Enum.split(-@keep_latest_n_segment_parts)
    |> then(fn {regular_segments, ll_segments} ->
      regular = Enum.flat_map(regular_segments, &do_serialize_segment(&1, false))
      ll = Enum.flat_map(ll_segments, &do_serialize_segment(&1, supports_ll_hls?))

      regular ++ ll
    end)
    |> Enum.join("\n")
  end

  defp do_serialize_segment(%Segment{} = segment, supports_ll_hls?) do
    [
      # serialize partial segments just for the last 4 live segments, otherwise just keep the regular segments
      if(supports_ll_hls?,
        do: serialize_partial_segments(segment),
        else: []
      ),
      serialize_regular_segment(segment)
    ]
    |> List.flatten()
  end

  defp serialize_regular_segment(%Segment{type: :partial}), do: []

  defp serialize_regular_segment(segment) do
    time = Ratio.to_float(segment.duration / Time.second())

    Enum.flat_map(segment.attributes, &SegmentAttribute.serialize/1) ++
      [
        "#EXTINF:#{time},",
        segment.name
      ]
  end

  defp serialize_partial_segments(%Segment{} = segment) do
    Enum.map(segment.parts, fn part ->
      time = Ratio.to_float(part.duration / Time.second())

      serialized = "#EXT-X-PART:DURATION=#{time},URI=\"#{part.name}\""

      if part.independent?,
        do: serialized <> ",INDEPENDENT=YES",
        else: serialized
    end)
  end

  defp serialize_ll_hls_tags(track, segments_to_skip_duration: segments_to_skip_duration) do
    supports_ll_hls? = Track.supports_partial_segments?(track)

    if supports_ll_hls? do
      target_partial_duration =
        Float.ceil(Ratio.to_float(track.partial_segment_duration / Time.second()), 3)

      """
      #EXT-X-SERVER-CONTROL:CAN-BLOCK-RELOAD=YES,PART-HOLD-BACK=#{3 * target_partial_duration}#{can_skip_until(segments_to_skip_duration)}
      #EXT-X-PART-INF:PART-TARGET=#{target_partial_duration}
      """
    else
      ""
    end
  end

  defp serialize_preload_hint_tag(true, %Track{} = track) do
    if Enum.empty?(track.segments) do
      ""
    else
      name = track.partial_naming_fun.(track, preload_hint?: true)

      "#EXT-X-PRELOAD-HINT:TYPE=PART,URI=\"#{name}\""
    end
  end

  defp serialize_preload_hint_tag(false, _track), do: ""

  defp can_skip_until(duration) when duration > 0,
    do: ",CAN-SKIP-UNTIL=#{duration}"

  defp can_skip_until(_duration), do: ""
end