// Simplify build
// -

use std::fs::File;

use chrono::{DateTime, Utc};
use rayon::iter::{ParallelBridge, ParallelIterator};
use tar::Archive;

use crate::recipe_functions::common;

pub trait Peekable {
    fn peek(&self) -> Result<Vec<String>, Box<dyn std::error::Error>>;
}

/// Is expected to get information about last build
pub struct LastBuildFirmware {
    pub path: String,
    pub date: DateTime<Utc>,
    pub is_full: bool,
    /// Should be added later by calling implemented functions
    pub entries: Vec<String>,
    pub tags: Option<Vec<String>>,
}

impl Peekable for LastBuildFirmware {
    fn peek(&self) -> Result<Vec<String>, Box<dyn std::error::Error>> {
        let mut peeked = Vec::new();

        let file = File::open(self.path.clone()).unwrap();
        let decompressed = flate2::read::GzDecoder::new(file);
        let mut ar = Archive::new(decompressed);

        for file2 in ar.entries().unwrap() {
            let f = file2.unwrap();
            peeked.push(f.path().unwrap().as_os_str().to_string_lossy().to_string());
        }

        Ok(peeked)
    }
}

pub fn read_last_build_firmwares() -> Result<Vec<LastBuildFirmware>, Box<dyn std::error::Error>> {
    // get config
    let ucfg = common::get_config();
    let firmware_dir = ucfg
        .get("FIRMWARE_DIR")
        .expect("Unknown firmware directory, check .tbcfg");

    // parallel walk to dir
    let result = walkdir::WalkDir::new(firmware_dir)
        .max_depth(2)
        .into_iter()
        .par_bridge()
        .filter(|w| {
            let filename = &w.as_ref().unwrap().clone();
            let file_clone = filename.file_name().to_str().unwrap();
            file_clone.ends_with(".tar") || file_clone.ends_with(".zip")
        })
        .map(|entry| {
            let dir = entry.unwrap();
            let meta = dir.clone().metadata().unwrap();

            let filename = dir.clone().path().to_str().unwrap().to_string();
            let mod_time: DateTime<Utc> = meta.modified().unwrap().into();
            let full_firmware = filename.clone().contains("full");

            LastBuildFirmware {
                path: filename,
                date: mod_time,
                is_full: full_firmware,
                entries: Vec::new(),
                tags: None,
            }
        })
        .collect();

    Ok(result)
}