use std::io::{BufRead, Error};
use std::path::PathBuf;

#[derive(Debug)]
pub(crate) struct Entry {
    filename: PathBuf
}

#[derive(Debug)]
pub(crate) struct Config {
    entries: Vec<Entry>
}

impl Entry {}

impl Config {}

pub(crate) fn create_config(reader: impl BufRead) -> Result<Config, String> {
    let lines= reader.lines();
    let(successful_lines, failed_lines) : (Vec<Result<String,Error>>, Vec<Result<String, Error>>) = lines.partition(Result::is_ok);

    let successful_lines : Vec<_> = successful_lines.into_iter().map(Result::unwrap).collect();
    let failed_lines : Vec<_> = failed_lines.into_iter().map(Result::unwrap_err).collect();

    if !failed_lines.is_empty() {
        return Result::Err(format!("Something went wrong when parsing file lines"));
    }

    let (entries, failures) : (Vec<Result<Entry, String>>, Vec<Result<Entry, String>>) = successful_lines.into_iter().map(|line| {
        match line.split_whitespace().collect::<Vec<&str>>().as_slice() {
            [s] => {
                return Result::Ok(Entry {filename: PathBuf::from(s)});
            }
            _ => {
                return Result::Err(format!("Line contains invalid Entry: {}", line));
            }
        }
    }).partition(Result::is_ok);

    let entries : Vec<_> = entries.into_iter().map(Result::unwrap).collect();
    let failures : Vec<_> = failures.into_iter().map(Result::unwrap_err).collect();

    if !failures.is_empty() {
        return Result::Err(failures.first().unwrap().to_string())
    }

    return Result::Ok(Config {entries});
}