mod config;

use crate::config::Config;
use anyhow::{Context, Error, Result};
use futures::{channel::mpsc, prelude::*};
use glib::{subclass::prelude::*, GBoxed, GString};
use gstreamer::{gst_element_error, prelude::*, Element};
use gstreamer_audio::AudioEncoder;
use gstreamer_base::prelude::*;
use std::{
    borrow::Cow,
    error::Error as StdError,
    ffi, fmt,
    path::{Path, PathBuf},
    result::Result as StdResult,
    sync::Arc,
};

#[derive(Clone, Debug, GBoxed)]
#[gboxed(type_name = "GBoxErrorWrapper")]
struct GBoxErrorWrapper(Arc<Error>);

impl GBoxErrorWrapper {
    fn new(err: Error) -> Self {
        GBoxErrorWrapper(Arc::new(err))
    }
}

impl StdError for GBoxErrorWrapper {
    fn source(&self) -> Option<&(dyn StdError + 'static)> {
        self.0.source()
    }
}

impl fmt::Display for GBoxErrorWrapper {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> StdResult<(), fmt::Error> {
        self.0.fmt(f)
    }
}

#[derive(Debug, derive_more::Display, derive_more::Error)]
#[display(fmt = "Received error from {}: {} (debug: {:?})", src, error, debug)]
struct GErrorMessage {
    src: String,
    error: String,
    debug: Option<String>,
    source: glib::Error,
}

fn gmake<T: IsA<Element>>(factory_name: &str) -> Result<T> {
    let res = gstreamer::ElementFactory::make(factory_name, None)
        .with_context(|| format!("could not make gstreamer Element \"{}\"", factory_name))?
        .downcast()
        .ok()
        .with_context(|| {
            format!(
                "could not cast gstreamer Element \"{}\" into `{}`",
                factory_name,
                std::any::type_name::<T>()
            )
        })?;
    Ok(res)
}

#[derive(Debug, Clone)]
struct ConvertionArgs {
    from: PathBuf,
    to: PathBuf,
    transcode: config::Transcode,
}

fn get_path_pairs(config: Config) -> impl Iterator<Item = ConvertionArgs> {
    walkdir::WalkDir::new(&config.from)
        .into_iter()
        .filter_map(|e| e.ok())
        .filter(|e| e.file_type().is_file())
        .filter_map(move |e| {
            let from_bytes = path_to_bytes(e.path());

            let transcode = config
                .matches
                .iter()
                .filter(|m| m.regex.is_match(from_bytes.as_ref()))
                .map(|m| m.to.clone())
                .next();
            let transcode = if let Some(transcode) = transcode {
                transcode
            } else {
                return None;
            };

            let mut to = config.to.join(e.path().strip_prefix(&config.from).unwrap());
            to.set_extension(transcode.extention());

            let is_newer = {
                // TODO: error handling
                let from_mtime = e.metadata().unwrap().modified().unwrap();
                let to_mtime = to.metadata().and_then(|md| md.modified());
                match to_mtime {
                    Ok(to_mtime) => to_mtime < from_mtime,
                    Err(err) if err.kind() == std::io::ErrorKind::NotFound => true,
                    Err(err) => panic!(err),
                }
            };

            if !is_newer {
                return None;
            }

            Some(ConvertionArgs {
                from: e.path().to_path_buf(),
                to,
                transcode,
            })
        })
}

fn main() -> Result<()> {
    gstreamer::init()?;
    let config = config::config().context("could not get the config")?;

    let (pair_tx, pair_rx) = mpsc::channel(16);

    // move blocking directory reading to an external thread
    let pair_producer = std::thread::spawn(|| {
        let produce_pairs = futures::stream::iter(get_path_pairs(config))
            .map(Ok)
            .forward(pair_tx)
            .map(|res| res.context("sending path pairs failed"));
        futures::executor::block_on(produce_pairs)
    });

    let transcoder = pair_rx.for_each_concurrent(num_cpus::get(), |args| async move {
        if let Err(err) = transcode(&args).await {
            println!(
                "err {} => {}:\n{:?}",
                args.from.display(),
                args.to.display(),
                err
            );
        }
    });
    futures::executor::block_on(transcoder);

    pair_producer
        .join()
        .expect("directory reading thread panicked")?;

    Ok(())
}

async fn transcode(args: &ConvertionArgs) -> Result<()> {
    let file_src: gstreamer_base::BaseSrc = gmake("filesrc")?;
    file_src.set_property("location", &path_to_gstring(&args.from))?;

    // encode into a tmp file first, then rename to actuall file name, that way we're writing
    // "whole" files to the intended file path, ignoring partial files in the mtime check
    let tmp_dest = args.to.with_extension("tmp");

    let decodebin: Element = gmake("decodebin")?;

    let src_elems: &[&Element] = &[file_src.upcast_ref(), &decodebin];

    let pipeline = gstreamer::Pipeline::new(None);

    pipeline.add_many(src_elems)?;
    Element::link_many(src_elems)?;

    // downgrade pipeline RC to a weak RC to break the reference cycle
    let pipeline_weak = pipeline.downgrade();

    let transcode_args = args.transcode.clone();

    let tmp_dest_clone = tmp_dest.clone();

    decodebin.connect_pad_added(move |decodebin, src_pad| {
        let insert_sink = || -> Result<()> {
            let pipeline = match pipeline_weak.upgrade() {
                Some(pipeline) => pipeline,
                None => {
                    // pipeline already destroyed... ignoring
                    return Ok(());
                }
            };

            let is_audio = src_pad.get_current_caps().and_then(|caps| {
                caps.get_structure(0).map(|s| {
                    let name = s.get_name();
                    name.starts_with("audio/")
                })
            });
            match is_audio {
                None => {
                    return Err(Error::msg(format!(
                        "Failed to get media type from pad {}",
                        src_pad.get_name()
                    )));
                }
                Some(false) => {
                    // not audio pad... ignoring
                    return Ok(());
                }
                Some(true) => {}
            }

            let resample: Element = gmake("audioresample")?;
            // quality from 0 to 10
            resample.set_property("quality", &7)?;

            let mut dest_elems = vec![
                resample,
                // `audioconvert` converts audio format, bitdepth, ...
                gmake("audioconvert")?,
            ];

            match &transcode_args {
                config::Transcode::Opus {
                    bitrate,
                    bitrate_type,
                } => {
                    let encoder: AudioEncoder = gmake("opusenc")?;
                    encoder.set_property(
                        "bitrate",
                        &i32::from(*bitrate)
                            .checked_mul(1_000)
                            .context("bitrate overflowed")?,
                    )?;
                    encoder.set_property_from_str(
                        "bitrate-type",
                        match bitrate_type {
                            config::OpusBitrateType::Vbr => "1",
                            config::OpusBitrateType::Cbr => "0",
                        },
                    );

                    dest_elems.push(encoder.upcast());
                    dest_elems.push(gmake("oggmux")?);
                }
            };

            let file_dest: gstreamer_base::BaseSink = gmake("filesink")?;
            file_dest.set_property("location", &path_to_gstring(&tmp_dest_clone))?;
            file_dest.set_sync(false);
            dest_elems.push(file_dest.upcast());

            let dest_elem_refs: Vec<_> = dest_elems.iter().collect();
            pipeline.add_many(&dest_elem_refs)?;
            Element::link_many(&dest_elem_refs)?;

            for e in &dest_elems {
                e.sync_state_with_parent()?;
            }

            let sink_pad = dest_elems
                .get(0)
                .unwrap()
                .get_static_pad("sink")
                .expect("1. dest element has no sinkpad");
            src_pad.link(&sink_pad)?;

            Ok(())
        };

        if let Err(err) = insert_sink() {
            let details = gstreamer::Structure::builder("error-details")
                .field("error", &GBoxErrorWrapper::new(err))
                .build();

            gst_element_error!(
                decodebin,
                gstreamer::LibraryError::Failed,
                ("Failed to insert sink"),
                details: details
            );
        }
    });

    let bus = pipeline.get_bus().context("pipe get bus")?;

    std::fs::create_dir_all(
        args.to
            .parent()
            .with_context(|| format!("could not get parent dir for {}", args.to.display()))?,
    )?;

    rm_file_on_err(&tmp_dest, async {
        pipeline
            .set_state(gstreamer::State::Playing)
            .context("Unable to set the pipeline to the `Playing` state")?;

        bus.stream()
            .map::<Result<bool>, _>(|msg| {
                use gstreamer::MessageView;

                match msg.view() {
                    MessageView::Eos(..) => {
                        // we need to actively stop pulling the stream, that's because stream will
                        // never end despite yielding an `Eos` message
                        Ok(false)
                    }
                    MessageView::Error(err) => {
                        pipeline.set_state(gstreamer::State::Null).context(
                            "Unable to set the pipeline to the `Null` state, after error",
                        )?;

                        let err = err
                            .get_details()
                            .and_then(|details| {
                                if details.get_name() != "error-details" {
                                    return None;
                                }

                                let err = details
                                    .get::<&GBoxErrorWrapper>("error")
                                    .unwrap()
                                    .map(|err| err.clone().into())
                                    .expect("error-details message without actual error");
                                Some(err)
                            })
                            .unwrap_or_else(|| {
                                GErrorMessage {
                                    src: msg
                                        .get_src()
                                        .map(|s| String::from(s.get_path_string()))
                                        .unwrap_or_else(|| String::from("None")),
                                    error: err.get_error().to_string(),
                                    debug: err.get_debug(),
                                    source: err.get_error(),
                                }
                                .into()
                            });
                        Err(err)
                    }
                    _ => Ok(true),
                }
            })
            .take_while(|e| {
                if let Ok(false) = e {
                    futures::future::ready(false)
                } else {
                    futures::future::ready(true)
                }
            })
            .try_for_each(|_| futures::future::ready(Ok(())))
            .await
            .context("failed converting")?;

        pipeline
            .set_state(gstreamer::State::Null)
            .context("Unable to set the pipeline to the `Null` state")?;

        std::fs::rename(&tmp_dest, &args.to)?;

        Ok(())
    })
    .await
}

async fn rm_file_on_err<F, T>(path: &Path, f: F) -> F::Output
where
    F: Future<Output = Result<T>>,
{
    match f.await {
        Err(err) => match std::fs::remove_file(path) {
            Ok(..) => Err(err),
            Err(rm_err) if rm_err.kind() == std::io::ErrorKind::NotFound => Err(err),
            Err(rm_err) => Err(rm_err)
                .context(format!("removing {}", path.display()))
                .context(err),
        },
        res @ Ok(..) => res,
    }
}

fn path_to_bytes(path: &Path) -> Cow<'_, [u8]> {
    // https://stackoverflow.com/a/59224987/5572146
    #[cfg(unix)]
    {
        use std::os::unix::ffi::OsStrExt;
        Cow::Borrowed(path.as_os_str().as_bytes())
    }

    #[cfg(windows)]
    {
        let mut buf = Vec::<u8>::new();
        // NOT TESTED
        // FIXME: test and post answer to https://stackoverflow.com/questions/38948669
        use std::os::windows::ffi::OsStrExt;
        buf.extend(
            path.as_os_str()
                .encode_wide()
                .map(|char| char.to_ne_bytes())
                .flatten(),
        );
        Cow::Owned(buf)
    }
}

fn path_to_gstring(path: &Path) -> GString {
    let buf = path_to_bytes(path);
    ffi::CString::new(buf)
        .expect("Path contained null byte")
        .into()
}