use std::{
    fs::{metadata, Permissions},
    path::PathBuf,
    str::FromStr,
};

use chrono::{DateTime, Datelike, Local};

use crate::error::ShellError;

use super::{Builtin, BuiltinConfig};

pub struct Ls;

impl Builtin for Ls {
    fn execute(&mut self, _: &mut BuiltinConfig, _: Vec<String>) -> Result<(), ShellError> {
        let dir = std::env::current_dir().unwrap_or(PathBuf::from_str("/").unwrap());
        let entries = match std::fs::read_dir(dir) {
            Ok(e) => e,
            Err(e) => return Err(ShellError::ExecuteFailure(e.to_string())),
        };

        //for entry in entries.by_ref().into_iter() {}

        println!(
            "{} | dir  | size   | modified   | accessed   | created    | readonly |",
            right_padding(" filename", 20)
        );

        for entry in entries {
            let Ok(entry) = entry else {
                eprintln!("Couldn't get directory entry");
                continue;
            };
            let metadata = match metadata(entry.path()) {
                Ok(m) => m,
                Err(_) => {
                    continue;
                }
            };

            let file_name = entry.file_name().to_string_lossy().to_string();

            let modified: DateTime<Local> = match metadata.modified() {
                Ok(t) => DateTime::from(t),
                Err(_) => Local::now(),
            };

            let accessed: DateTime<Local> = match metadata.accessed() {
                Ok(t) => DateTime::from(t),
                Err(_) => Local::now(),
            };

            let created: DateTime<Local> = match metadata.created() {
                Ok(t) => DateTime::from(t),
                Err(_) => Local::now(),
            };

            let permissions = metadata.permissions();

            let mut file_type = "unknown";
            if metadata.file_type().is_dir() {
                file_type = "dir"
            } else if metadata.file_type().is_file() {
                file_type = "file"
            } else if metadata.file_type().is_symlink() {
                file_type = "link"
            }
            println!(
                "{}",
                format_line(
                    20,
                    &file_name,
                    file_type,
                    metadata.len(),
                    modified,
                    accessed,
                    created,
                    permissions
                )
            );
        }
        Ok(())
    }
}

fn format_filesize(filesize: u64) -> String {
    if filesize > 9_999 && filesize <= 999_999 {
        format!("{}KB", filesize / 1_000)
    } else if filesize > 999_999 && filesize <= 999_999_999 {
        format!("{}MB", filesize / 1_000_000)
    } else if filesize > 999_999_999 {
        format!("{}GB", filesize / 1_000_000_000)
    } else {
        format!("{}B", filesize)
    }
}

fn format_date(date: DateTime<Local>) -> String {
    let now: DateTime<Local> = Local::now();
    if date.day() != now.day() || date.month() != now.month() || date.year() != now.year() {
        date.format("%F").to_string()
    } else {
        date.format("%T").to_string()
    }
}

fn format_line(
    max_name_len: usize,
    file_name: &str,
    file_type: &str,
    file_size: u64,
    modified: DateTime<Local>,
    accessed: DateTime<Local>,
    created: DateTime<Local>,
    permissions: Permissions,
) -> String {
    format!(
        "{} | {:4} | {:6} | {:<10} | {:<10} | {:<10} | {:<5}    |",
        right_padding(file_name, max_name_len),
        file_type,
        format_filesize(file_size),
        format_date(modified),
        format_date(accessed),
        format_date(created),
        permissions.readonly().to_string(),
    )
}

fn right_padding(s: &str, max: usize) -> String {
    let mut tmp = String::from_str(s).unwrap();
    for _ in tmp.len()..max {
        tmp.push(' ');
    }
    tmp
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_format_filesize_bytes() {
        assert_eq!(format_filesize(6969), "6969B");
    }

    #[test]
    fn test_format_filesize_kilobytes() {
        assert_eq!(format_filesize(69420), "69KB");
    }

    #[test]
    fn test_format_filesize_megabytes() {
        assert_eq!(format_filesize(69420420), "69MB");
    }

    #[test]
    fn test_format_filesize_gigabytes() {
        assert_eq!(format_filesize(69420420420), "69GB");
    }
}