/*
    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
    Copyright (C) 2023 metamuffin <metamuffin.org>
*/
use super::ui::error::MyError;
use crate::library::Library;
use anyhow::Result;
use anyhow::{anyhow, Context};
use jellyremuxer::RemuxerContext;
use log::warn;
use log::{debug, info};
use rocket::http::{Header, Status};
use rocket::request::{self, FromRequest};
use rocket::response;
use rocket::response::Responder;
use rocket::Request;
use rocket::Response;
use rocket::{get, http::ContentType, State};
use std::ops::Deref;
use std::ops::Range;
use std::path::PathBuf;
use tokio::io::{duplex, DuplexStream};
use tokio_util::io::SyncIoBridge;

pub fn stream_uri(path: &PathBuf, tracks: &Vec<u64>, webm: bool) -> String {
    format!(
        "/stream/{}?tracks={}&webm={}",
        path.to_str().unwrap().to_string(),
        tracks
            .iter()
            .map(|v| format!("{v}"))
            .collect::<Vec<_>>()
            .join(","),
        if webm { "1" } else { "0" }
    )
}

#[get("/stream/<path..>?<tracks>&<webm>")]
pub fn r_stream(
    path: PathBuf,
    webm: Option<bool>,
    tracks: String,
    remuxer: &State<RemuxerContext>,
    library: &State<Library>,
    range: Option<RequestRange>,
) -> Result<StreamResponse, MyError> {
    info!("stream request (range={range:?})");
    let (a, b) = duplex(1024);
    let path = path.to_str().unwrap().to_string();
    let item = library
        .nested(&path)
        .context("retrieving library node")?
        .get_item()?;
    let remuxer = remuxer.deref().clone();
    let tracks = tracks
        .split(",")
        .map(|e| e.parse().map_err(|_| anyhow!("invalid number")))
        .into_iter()
        .collect::<Result<Vec<_>, _>>()?;

    let b = SyncIoBridge::new(b);

    tokio::task::spawn_blocking(move || {
        if let Err(e) = remuxer.generate_into(
            b,
            0,
            item.fs_path.parent().unwrap().to_path_buf(),
            item.info.clone(),
            tracks,
            webm.unwrap_or(false),
        ) {
            warn!("stream stopped: {e}")
        }
    });
    debug!("starting stream");
    Ok(StreamResponse { stream: a, range })
}

pub struct StreamResponse {
    stream: DuplexStream,
    range: Option<RequestRange>,
}

#[rocket::async_trait]
impl<'r> Responder<'r, 'static> for StreamResponse {
    fn respond_to(self, _: &'r Request<'_>) -> response::Result<'static> {
        let mut b = Response::build();
        if let Some(range) = self.range {
            b.status(Status::PartialContent);
            b.header(Header::new("content-range", range.to_cr_hv()));
        }
        b.header(Header::new("accept-ranges", "bytes"))
            .header(ContentType::WEBM)
            .streamed_body(self.stream)
            .ok()
    }
}

#[derive(Debug)]
pub struct RequestRange(Vec<Range<Option<usize>>>);

impl RequestRange {
    pub fn to_cr_hv(&self) -> String {
        assert_eq!(self.0.len(), 1);
        format!(
            "bytes {}-{}/*",
            self.0[0]
                .start
                .map(|e| format!("{e}"))
                .unwrap_or(String::new()),
            self.0[0]
                .end
                .map(|e| format!("{e}"))
                .unwrap_or(String::new())
        )
    }
    pub fn from_hv(s: &str) -> Result<Self> {
        Ok(Self(
            s.strip_prefix("bytes=")
                .ok_or(anyhow!("prefix expected"))?
                .split(",")
                .map(|s| {
                    let (l, r) = s
                        .split_once("-")
                        .ok_or(anyhow!("range delimeter missing"))?;
                    let km = |s: &str| {
                        if s.is_empty() {
                            Ok::<_, anyhow::Error>(None)
                        } else {
                            Ok(Some(s.parse()?))
                        }
                    };
                    Ok(km(l)?..km(r)?)
                })
                .into_iter()
                .collect::<Result<Vec<_>>>()?,
        ))
    }
}

#[rocket::async_trait]
impl<'r> FromRequest<'r> for RequestRange {
    type Error = anyhow::Error;

    async fn from_request(req: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
        match req.headers().get("range").next() {
            Some(v) => match Self::from_hv(v) {
                Ok(v) => rocket::outcome::Outcome::Success(v),
                Err(e) => rocket::outcome::Outcome::Failure((Status::BadRequest, e)),
            },
            None => rocket::outcome::Outcome::Forward(()),
        }
    }
}