use crate::check_result::{
    flatten_check_results, pass, sequence_check_results, CheckError, CheckResult,
};
use crate::references;
use crate::utils;
use crate::utils::{BASE_SUBPATH, PACKAGE_NIX_FILENAME};
use lazy_static::lazy_static;
use regex::Regex;
use std::path::{Path, PathBuf};

lazy_static! {
    static ref SHARD_NAME_REGEX: Regex = Regex::new(r"^[a-z0-9_-]{1,2}$").unwrap();
    static ref PACKAGE_NAME_REGEX: Regex = Regex::new(r"^[a-zA-Z0-9_-]+$").unwrap();
}

/// Contains information about the structure of the pkgs/by-name directory of a Nixpkgs
pub struct Nixpkgs {
    /// The path to nixpkgs
    pub path: PathBuf,
    /// The names of all packages declared in pkgs/by-name
    pub package_names: Vec<String>,
}

impl Nixpkgs {
    // Some utility functions for the basic structure

    pub fn shard_for_package(package_name: &str) -> String {
        package_name.to_lowercase().chars().take(2).collect()
    }

    pub fn relative_dir_for_shard(shard_name: &str) -> PathBuf {
        PathBuf::from(format!("{BASE_SUBPATH}/{shard_name}"))
    }

    pub fn relative_dir_for_package(package_name: &str) -> PathBuf {
        Nixpkgs::relative_dir_for_shard(&Nixpkgs::shard_for_package(package_name))
            .join(package_name)
    }

    pub fn relative_file_for_package(package_name: &str) -> PathBuf {
        Nixpkgs::relative_dir_for_package(package_name).join(PACKAGE_NIX_FILENAME)
    }
}

/// Read the structure of a Nixpkgs directory, displaying errors on the writer.
/// May return early with I/O errors.
pub fn check_structure(path: &Path) -> CheckResult<Nixpkgs> {
    let base_dir = path.join(BASE_SUBPATH);

    let check_results = utils::read_dir_sorted(&base_dir)?
        .into_iter()
        .map(|shard_entry| {
            let shard_path = shard_entry.path();
            let shard_name = shard_entry.file_name().to_string_lossy().into_owned();
            let relative_shard_path = Nixpkgs::relative_dir_for_shard(&shard_name);

            if shard_name == "README.md" {
                // README.md is allowed to be a file and not checked
                pass(vec![])
            } else if !shard_path.is_dir() {
                CheckError::ShardNonDir {
                    relative_shard_path: relative_shard_path.clone(),
                }
                .into_result()
                // we can't check for any other errors if it's a file, since there's no subdirectories to check
            } else {
                let shard_name_valid = SHARD_NAME_REGEX.is_match(&shard_name);
                let check_result = if !shard_name_valid {
                    CheckError::InvalidShardName {
                        relative_shard_path: relative_shard_path.clone(),
                        shard_name: shard_name.clone(),
                    }
                    .into_result()
                } else {
                    pass(())
                };

                let entries = utils::read_dir_sorted(&shard_path)?;

                let duplicate_check_results = entries
                    .iter()
                    .zip(entries.iter().skip(1))
                    .filter(|(l, r)| {
                        l.file_name().to_ascii_lowercase() == r.file_name().to_ascii_lowercase()
                    })
                    .map(|(l, r)| {
                        CheckError::CaseSensitiveDuplicate {
                            relative_shard_path: relative_shard_path.clone(),
                            first: l.file_name(),
                            second: r.file_name(),
                        }
                        .into_result::<()>()
                    });

                let check_result = sequence_check_results(
                    check_result,
                    flatten_check_results(duplicate_check_results, |_| ()),
                );

                let check_results = entries.into_iter().map(|package_entry| {
                    let package_path = package_entry.path();
                    let package_name = package_entry.file_name().to_string_lossy().into_owned();
                    let relative_package_dir =
                        PathBuf::from(format!("{BASE_SUBPATH}/{shard_name}/{package_name}"));

                    if !package_path.is_dir() {
                        CheckError::PackageNonDir {
                            relative_package_dir: relative_package_dir.clone(),
                        }
                        .into_result()
                    } else {
                        let package_name_valid = PACKAGE_NAME_REGEX.is_match(&package_name);
                        let name_check_result = if !package_name_valid {
                            CheckError::InvalidPackageName {
                                relative_package_dir: relative_package_dir.clone(),
                                package_name: package_name.clone(),
                            }
                            .into_result()
                        } else {
                            pass(())
                        };

                        let correct_relative_package_dir =
                            Nixpkgs::relative_dir_for_package(&package_name);
                        let shard_check_result =
                            if relative_package_dir != correct_relative_package_dir {
                                // Only show this error if we have a valid shard and package name
                                // Because if one of those is wrong, you should fix that first
                                if shard_name_valid && package_name_valid {
                                    CheckError::IncorrectShard {
                                        relative_package_dir: relative_package_dir.clone(),
                                        correct_relative_package_dir: correct_relative_package_dir
                                            .clone(),
                                    }
                                    .into_result()
                                } else {
                                    pass(())
                                }
                            } else {
                                pass(())
                            };

                        let package_nix_path = package_path.join(PACKAGE_NIX_FILENAME);
                        let package_nix_check_result = if !package_nix_path.exists() {
                            CheckError::PackageNixNonExistent {
                                relative_package_dir: relative_package_dir.clone(),
                            }
                            .into_result()
                        } else if package_nix_path.is_dir() {
                            CheckError::PackageNixDir {
                                relative_package_dir: relative_package_dir.clone(),
                            }
                            .into_result()
                        } else {
                            pass(())
                        };

                        let reference_check_result = references::check_references(
                            &relative_package_dir,
                            &path.join(&relative_package_dir),
                        );

                        flatten_check_results(
                            [
                                name_check_result,
                                shard_check_result,
                                package_nix_check_result,
                                reference_check_result,
                            ],
                            |_| package_name.clone(),
                        )
                    }
                });

                sequence_check_results(check_result, flatten_check_results(check_results, |x| x))
            }
        });

    flatten_check_results(check_results, |x| Nixpkgs {
        path: path.to_owned(),
        package_names: x.into_iter().flatten().collect::<Vec<_>>(),
    })
}