use std::{
    env, fmt,
    fs::File,
    path::{Path, PathBuf},
    process,
    str::FromStr,
};

use chrono::NaiveTime;
use log::LevelFilter;
use serde::{de, Deserialize, Deserializer, Serialize, Serializer};
use shlex::split;

use super::vec_strings;
use crate::utils::{free_tcp_socket, home_dir, time_to_sec, OutputMode::*};

pub const DUMMY_LEN: f64 = 60.0;
pub const IMAGE_FORMAT: [&str; 21] = [
    "bmp", "dds", "dpx", "exr", "gif", "hdr", "j2k", "jpg", "jpeg", "pcx", "pfm", "pgm", "phm",
    "png", "psd", "ppm", "sgi", "svg", "tga", "tif", "webp",
];

// Some well known errors can be safely ignore
pub const FFMPEG_IGNORE_ERRORS: [&str; 11] = [
    "ac-tex damaged",
    "codec s302m, is muxed as a private data stream",
    "corrupt decoded frame in stream",
    "corrupt input packet in stream",
    "end mismatch left",
    "Packet corrupt",
    "Referenced QT chapter track not found",
    "skipped MB in I-frame at",
    "Thread message queue blocking",
    "Warning MVs not available",
    "frame size not set",
];

pub const FFMPEG_UNRECOVERABLE_ERRORS: [&str; 5] = [
    "Address already in use",
    "Invalid argument",
    "Numerical result",
    "Error initializing complex filters",
    "Error while decoding stream #0:0: Invalid data found when processing input",
];

#[derive(Debug, Serialize, Deserialize, Clone, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum OutputMode {
    Desktop,
    HLS,
    Null,
    Stream,
}

impl FromStr for OutputMode {
    type Err = String;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        match input {
            "desktop" => Ok(Self::Desktop),
            "hls" => Ok(Self::HLS),
            "null" => Ok(Self::Null),
            "stream" => Ok(Self::Stream),
            _ => Err("Use 'desktop', 'hls', 'null' or 'stream'".to_string()),
        }
    }
}

#[derive(Debug, Serialize, Deserialize, Clone, Eq, PartialEq)]
#[serde(rename_all = "lowercase")]
pub enum ProcessMode {
    Folder,
    Playlist,
}

impl fmt::Display for ProcessMode {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match *self {
            ProcessMode::Folder => write!(f, "folder"),
            ProcessMode::Playlist => write!(f, "playlist"),
        }
    }
}

impl FromStr for ProcessMode {
    type Err = String;

    fn from_str(input: &str) -> Result<Self, Self::Err> {
        match input {
            "folder" => Ok(Self::Folder),
            "playlist" => Ok(Self::Playlist),
            _ => Err("Use 'folder' or 'playlist'".to_string()),
        }
    }
}

pub fn string_to_log_level<'de, D>(deserializer: D) -> Result<LevelFilter, D::Error>
where
    D: Deserializer<'de>,
{
    let s: String = Deserialize::deserialize(deserializer)?;

    match s.to_lowercase().as_str() {
        "debug" => Ok(LevelFilter::Debug),
        "error" => Ok(LevelFilter::Error),
        "info" => Ok(LevelFilter::Info),
        "trace" => Ok(LevelFilter::Trace),
        "warning" => Ok(LevelFilter::Warn),
        "off" => Ok(LevelFilter::Off),
        _ => Err(de::Error::custom("Error level not exists!")),
    }
}

fn log_level_to_string<S>(l: &LevelFilter, s: S) -> Result<S::Ok, S::Error>
where
    S: Serializer,
{
    match l {
        LevelFilter::Debug => s.serialize_str("DEBUG"),
        LevelFilter::Error => s.serialize_str("ERROR"),
        LevelFilter::Info => s.serialize_str("INFO"),
        LevelFilter::Trace => s.serialize_str("TRACE"),
        LevelFilter::Warn => s.serialize_str("WARNING"),
        LevelFilter::Off => s.serialize_str("OFF"),
    }
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Template {
    pub sources: Vec<Source>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Source {
    pub start: NaiveTime,
    pub duration: NaiveTime,
    pub shuffle: bool,
    pub paths: Vec<PathBuf>,
}

/// Global Config
///
/// This we init ones, when ffplayout is starting and use them globally in the hole program.
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct PlayoutConfig {
    pub general: General,
    pub rpc_server: RpcServer,
    pub mail: Mail,
    pub logging: Logging,
    pub processing: Processing,
    pub ingest: Ingest,
    pub playlist: Playlist,
    pub storage: Storage,
    pub text: Text,
    #[serde(default)]
    pub task: Task,
    pub out: Out,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct General {
    pub help_text: String,
    pub stop_threshold: f64,

    #[serde(default, skip_serializing, skip_deserializing)]
    pub config_path: String,

    #[serde(default)]
    pub stat_file: String,

    #[serde(skip_serializing, skip_deserializing)]
    pub generate: Option<Vec<String>>,

    #[serde(skip_serializing, skip_deserializing)]
    pub ffmpeg_filters: Vec<String>,

    #[serde(skip_serializing, skip_deserializing)]
    pub ffmpeg_libs: Vec<String>,

    #[serde(skip_serializing, skip_deserializing)]
    pub template: Option<Template>,

    #[serde(default, skip_serializing, skip_deserializing)]
    pub validate: bool,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct RpcServer {
    pub help_text: String,
    pub enable: bool,
    pub address: String,
    pub authorization: String,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Mail {
    pub help_text: String,
    pub subject: String,
    pub smtp_server: String,
    pub starttls: bool,
    pub sender_addr: String,
    pub sender_pass: String,
    pub recipient: String,
    pub mail_level: String,
    pub interval: u64,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Logging {
    pub help_text: String,
    pub log_to_file: bool,
    pub backup_count: usize,
    pub local_time: bool,
    pub timestamp: bool,
    #[serde(alias = "log_path")]
    pub path: PathBuf,
    #[serde(
        alias = "log_level",
        serialize_with = "log_level_to_string",
        deserialize_with = "string_to_log_level"
    )]
    pub level: LevelFilter,
    pub ffmpeg_level: String,
    pub ingest_level: Option<String>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Processing {
    pub help_text: String,
    pub mode: ProcessMode,
    #[serde(default)]
    pub audio_only: bool,
    #[serde(default = "default_track_index")]
    pub audio_track_index: i32,
    #[serde(default)]
    pub copy_audio: bool,
    #[serde(default)]
    pub copy_video: bool,
    pub width: i64,
    pub height: i64,
    pub aspect: f64,
    pub fps: f64,
    pub add_logo: bool,
    pub logo: String,
    pub logo_scale: String,
    pub logo_opacity: f32,
    pub logo_filter: String,
    #[serde(default = "default_tracks")]
    pub audio_tracks: i32,
    #[serde(default = "default_channels")]
    pub audio_channels: u8,
    pub volume: f64,
    #[serde(default)]
    pub custom_filter: String,

    #[serde(skip_serializing, skip_deserializing)]
    pub cmd: Option<Vec<String>>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Ingest {
    pub help_text: String,
    pub enable: bool,
    input_param: String,
    #[serde(default)]
    pub custom_filter: String,

    #[serde(skip_serializing, skip_deserializing)]
    pub input_cmd: Option<Vec<String>>,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Playlist {
    pub help_text: String,
    pub path: PathBuf,
    pub day_start: String,

    #[serde(skip_serializing, skip_deserializing)]
    pub start_sec: Option<f64>,

    pub length: String,

    #[serde(skip_serializing, skip_deserializing)]
    pub length_sec: Option<f64>,

    pub infinit: bool,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Storage {
    pub help_text: String,
    pub path: PathBuf,
    #[serde(skip_serializing, skip_deserializing)]
    pub paths: Vec<PathBuf>,
    #[serde(alias = "filler_clip")]
    pub filler: PathBuf,
    pub extensions: Vec<String>,
    pub shuffle: bool,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Text {
    pub help_text: String,
    pub add_text: bool,

    #[serde(skip_serializing, skip_deserializing)]
    pub node_pos: Option<usize>,

    #[serde(skip_serializing, skip_deserializing)]
    pub zmq_stream_socket: Option<String>,

    #[serde(skip_serializing, skip_deserializing)]
    pub zmq_server_socket: Option<String>,

    pub fontfile: String,
    pub text_from_filename: bool,
    pub style: String,
    pub regex: String,
}

#[derive(Debug, Default, Serialize, Deserialize, Clone)]
pub struct Task {
    pub enable: bool,
    pub path: PathBuf,
}

#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Out {
    pub help_text: String,
    pub mode: OutputMode,
    pub output_param: String,

    #[serde(skip_serializing, skip_deserializing)]
    pub output_count: usize,
    #[serde(skip_serializing, skip_deserializing)]
    pub output_filter: Option<String>,
    #[serde(skip_serializing, skip_deserializing)]
    pub output_cmd: Option<Vec<String>>,
}

fn default_track_index() -> i32 {
    -1
}

fn default_tracks() -> i32 {
    1
}

fn default_channels() -> u8 {
    2
}

impl PlayoutConfig {
    /// Read config from YAML file, and set some extra config values.
    pub fn new(cfg_path: Option<PathBuf>) -> Self {
        let mut config_path = PathBuf::from("/etc/ffplayout/ffplayout.yml");

        if let Some(cfg) = cfg_path {
            config_path = cfg;
        }

        if !config_path.is_file() {
            if Path::new("./assets/ffplayout.yml").is_file() {
                config_path = PathBuf::from("./assets/ffplayout.yml")
            } else if let Some(p) = env::current_exe().ok().as_ref().and_then(|op| op.parent()) {
                config_path = p.join("ffplayout.yml")
            };
        }

        let f = match File::open(&config_path) {
            Ok(file) => file,
            Err(_) => {
                println!(
                    "{config_path:?} doesn't exists!\nPut \"ffplayout.yml\" in \"/etc/playout/\" or beside the executable!"
                );
                process::exit(1);
            }
        };

        let mut config: PlayoutConfig =
            serde_yaml::from_reader(f).expect("Could not read config file.");
        config.general.generate = None;

        config.general.config_path = config_path.to_string_lossy().to_string();

        config.general.stat_file = home_dir()
            .unwrap_or_else(env::temp_dir)
            .join(if config.general.stat_file.is_empty() {
                ".ffp_status"
            } else {
                &config.general.stat_file
            })
            .display()
            .to_string();

        if config.logging.ingest_level.is_none() {
            config.logging.ingest_level = Some(config.logging.ffmpeg_level.clone())
        }

        config.playlist.start_sec = Some(time_to_sec(&config.playlist.day_start));

        if config.playlist.length.contains(':') {
            config.playlist.length_sec = Some(time_to_sec(&config.playlist.length));
        } else {
            config.playlist.length_sec = Some(86400.0);
        }

        if config.processing.add_logo && !Path::new(&config.processing.logo).is_file() {
            config.processing.add_logo = false;
        }

        config.processing.logo_scale = config
            .processing
            .logo_scale
            .trim_end_matches('~')
            .to_string();

        if config.processing.audio_tracks < 1 {
            config.processing.audio_tracks = 1
        }

        let bitrate = format!(
            "{}k",
            config.processing.width * config.processing.height / 16
        );

        let buff_size = format!(
            "{}k",
            (config.processing.width * config.processing.height / 16) / 2
        );

        let mut process_cmd = vec_strings![];

        if config.processing.audio_only {
            process_cmd.append(&mut vec_strings!["-vn"]);
        } else if config.processing.copy_video {
            process_cmd.append(&mut vec_strings!["-c:v", "copy"]);
        } else {
            process_cmd.append(&mut vec_strings![
                "-pix_fmt",
                "yuv420p",
                "-r",
                &config.processing.fps,
                "-c:v",
                "mpeg2video",
                "-g",
                "1",
                "-b:v",
                &bitrate,
                "-minrate",
                &bitrate,
                "-maxrate",
                &bitrate,
                "-bufsize",
                &buff_size
            ]);
        }

        if config.processing.copy_audio {
            process_cmd.append(&mut vec_strings!["-c:a", "copy"]);
        } else {
            process_cmd.append(&mut pre_audio_codec(
                &config.processing.custom_filter,
                &config.ingest.custom_filter,
                config.processing.audio_channels,
            ));
        }

        process_cmd.append(&mut vec_strings!["-f", "mpegts", "-"]);

        config.processing.cmd = Some(process_cmd);

        config.ingest.input_cmd = split(config.ingest.input_param.as_str());

        config.out.output_count = 1;
        config.out.output_filter = None;

        if config.out.mode == Null {
            config.out.output_cmd = Some(vec_strings!["-f", "null", "-"]);
        } else if let Some(mut cmd) = split(config.out.output_param.as_str()) {
            // get output count according to the var_stream_map value, or by counting output parameters
            if let Some(i) = cmd.clone().iter().position(|m| m == "-var_stream_map") {
                config.out.output_count = cmd[i + 1].split_whitespace().count();
            } else {
                config.out.output_count = cmd
                    .iter()
                    .enumerate()
                    .filter(|(i, p)| i > &0 && !p.starts_with('-') && !cmd[i - 1].starts_with('-'))
                    .count();
            }

            if let Some(i) = cmd.clone().iter().position(|r| r == "-filter_complex") {
                config.out.output_filter = Some(cmd[i + 1].clone());
                cmd.remove(i);
                cmd.remove(i);
            }

            config.out.output_cmd = Some(cmd);
        }

        // when text overlay without text_from_filename is on, turn also the RPC server on,
        // to get text messages from it
        if config.text.add_text && !config.text.text_from_filename {
            config.rpc_server.enable = true;
            config.text.zmq_stream_socket = free_tcp_socket(String::new());
            config.text.zmq_server_socket =
                free_tcp_socket(config.text.zmq_stream_socket.clone().unwrap_or_default());
            config.text.node_pos = Some(2);
        } else {
            config.text.zmq_stream_socket = None;
            config.text.zmq_server_socket = None;
            config.text.node_pos = None;
        }

        config
    }
}

impl Default for PlayoutConfig {
    fn default() -> Self {
        Self::new(None)
    }
}

/// When custom_filter contains loudnorm filter use a different audio encoder,
/// s302m has higher quality, but is experimental
/// and works not well together with the loudnorm filter.
fn pre_audio_codec(proc_filter: &str, ingest_filter: &str, channel_count: u8) -> Vec<String> {
    let mut codec = vec_strings![
        "-c:a",
        "s302m",
        "-strict",
        "-2",
        "-sample_fmt",
        "s16",
        "-ar",
        "48000",
        "-ac",
        channel_count
    ];

    if proc_filter.contains("loudnorm") || ingest_filter.contains("loudnorm") {
        codec = vec_strings![
            "-c:a",
            "mp2",
            "-b:a",
            "384k",
            "-ar",
            "48000",
            "-ac",
            channel_count
        ];
    }

    codec
}