use crate::error;
use crate::git::{GitFile, GitObject, GitRepo};
use clap::Parser;
use serde::Deserialize;
use std::collections::{BTreeMap, HashMap, HashSet};
use std::fs::{create_dir_all, read_dir, read_to_string};
use std::hash::{Hash, Hasher};
use std::path::{Path, PathBuf};
use std::sync::atomic::Ordering;

#[derive(Parser, Debug)]
#[command(author = "Trevor Bentley", version, about, long_about = None)]
#[command(help_template = "\
{name} v{version}, by {author-with-newline}
{about-with-newline}
{usage-heading} {usage}

{all-args}{after-help}
")]
struct CliArgs {
    /// Path to TOML configuration file
    #[arg(short, long, value_name = "FILE")]
    config: Option<PathBuf>,
    /// Specify path to a repository.  Overrides config TOML.  Can use multiple times.
    #[arg(short, long)]
    repo: Vec<PathBuf>,
    /// Generate a site suitable for local browsing (file://)
    #[arg(short, long)]
    local: bool,
    /// Open browser to repository listing after generation.
    #[arg(short, long)]
    open: bool,
    /// Don't show any output, except errors and warnings
    #[arg(short, long)]
    quiet: bool,
    /// Increase verbosity of output.  Specify up to 4 times.
    #[arg(short, long, action = clap::ArgAction::Count)]
    verbose: u8,
}

pub struct GitsyCli {
    pub path: PathBuf,
    pub dir: PathBuf,
    pub is_local: bool,
    pub should_open: bool,
    pub repos: Vec<PathBuf>,
}

impl GitsyCli {
    pub fn new() -> Self {
        let cli = CliArgs::parse();
        let config_path = cli.config.as_deref().unwrap_or(Path::new("config.toml")).to_owned();
        let config_dir = config_path
            .parent()
            .expect("Config file not in valid directory.")
            .to_owned();
        let config_dir = match config_dir.to_str().unwrap_or_default().len() > 0 {
            true => config_dir,
            false => PathBuf::from("."),
        };
        let config_path = match config_path.canonicalize() {
            Ok(d) => d,
            _ => config_path.clone(),
        };
        let config_dir = match config_dir.canonicalize() {
            Ok(d) => d,
            _ => config_dir.clone(),
        };
        crate::util::VERBOSITY.store(
            match cli.quiet {
                true => 0,
                false => (cli.verbose + 1).into(),
            },
            Ordering::Relaxed,
        );
        GitsyCli {
            path: config_path,
            dir: config_dir,
            is_local: cli.local,
            should_open: cli.open,
            repos: cli.repo,
        }
    }
}

#[derive(Deserialize, Debug)]
pub struct GitsySettingsTemplates {
    pub path: PathBuf,
    pub repo_list: Option<String>,
    pub repo_summary: Option<String>,
    pub history: Option<String>,
    pub commit: Option<String>,
    pub branches: Option<String>,
    pub branch: Option<String>,
    pub tags: Option<String>,
    pub tag: Option<String>,
    pub files: Option<String>,
    pub file: Option<String>,
    pub dir: Option<String>,
    pub error: Option<String>,
}

#[derive(Deserialize, Debug)]
pub struct GitsySettingsOutputs {
    pub path: PathBuf,
    pub cloned_repos: Option<String>,
    pub repo_list: Option<String>,
    pub repo_summary: Option<String>,
    pub history: Option<String>,
    pub commit: Option<String>,
    pub branches: Option<String>,
    pub branch: Option<String>,
    pub tags: Option<String>,
    pub tag: Option<String>,
    pub files: Option<String>,
    pub file: Option<String>,
    pub dir: Option<String>,
    pub error: Option<String>,
    pub syntax_css: Option<String>,
    pub global_assets: Option<String>,
    pub repo_assets: Option<String>,
}

macro_rules! output_path_fn {
    ($var:ident, $obj:ty, $id:ident, $is_dir:expr, $default:expr) => {
        pub fn $var(&self, repo: Option<&GitRepo>, obj: Option<&$obj>) -> String {
            let tmpl_str = self.$var.as_deref().unwrap_or($default).to_string();
            let tmpl_str = match (tmpl_str.contains("%REPO%"), repo.is_some()) {
                (true, true) => {
                    let name = repo.map(|x| &x.name).unwrap();
                    tmpl_str.replace("%REPO%", name)
                }
                (true, false) => {
                    panic!("%REPO% variable not available for output path: {}", tmpl_str);
                }
                _ => tmpl_str,
            };
            let tmpl_str = match (tmpl_str.contains("%ID%"), obj.is_some()) {
                (true, true) => {
                    let name = obj.map(|x| &x.$id).unwrap();
                    tmpl_str.replace("%ID%", name)
                }
                (true, false) => {
                    panic!("%ID% variable not available for output path: {}", tmpl_str);
                }
                _ => tmpl_str,
            };
            let tmpl = PathBuf::from(tmpl_str);
            let mut path = self.path.clone().canonicalize().expect(&format!(
                "ERROR: unable to canonicalize output path: {}",
                self.path.display()
            ));
            path.push(tmpl);
            match $is_dir {
                true => {
                    let _ = create_dir_all(&path);
                }
                false => {
                    if let Some(dir) = path.parent() {
                        let _ = create_dir_all(dir);
                    }
                }
            }
            path.to_str()
                .expect(&format!("Output is not a valid path: {}", path.display()))
                .into()
        }
    };
}
//step_map_first!(boil_in_wort, Boil, Wort, |b: &Boil| { b.wort_start() });

#[rustfmt::skip]
impl GitsySettingsOutputs {
    output_path_fn!(repo_list,       GitObject, full_hash, false, "repos.html");
    output_path_fn!(repo_summary,    GitObject, full_hash, false, "%REPO%/summary.html");
    output_path_fn!(history,         GitObject, full_hash, false, "%REPO%/history%PAGE%.html");
    output_path_fn!(commit,          GitObject, full_hash, false, "%REPO%/commit/%ID%.html");
    output_path_fn!(branches,        GitObject, full_hash, false, "%REPO%/branches%PAGE%.html");
    output_path_fn!(branch,          GitObject, full_hash, false, "%REPO%/branch/%ID%.html");
    output_path_fn!(tags,            GitObject, full_hash, false, "%REPO%/tags%PAGE%.html");
    output_path_fn!(tag,             GitObject, full_hash, false, "%REPO%/tag/%ID%.html");
    output_path_fn!(files,           GitObject, full_hash, false, "%REPO%/files.html");
    output_path_fn!(file,            GitFile,   id,        false, "%REPO%/file/%ID%.html");
    output_path_fn!(syntax_css,      GitObject, full_hash, false, "%REPO%/file/syntax.css");
    output_path_fn!(dir,             GitFile,   id,        false, "%REPO%/dir/%ID%.html");
    output_path_fn!(error,           GitObject, full_hash, false, "404.html");
    output_path_fn!(global_assets,   GitObject, full_hash, true,  "assets/");
    output_path_fn!(repo_assets,     GitObject, full_hash, true,  "%REPO%/assets/");

    pub fn output_dir(&self) -> String {
        self.path.clone().canonicalize()
            .expect(&format!("ERROR: unable to canonicalize output path: {}", self.path.display()))
            .to_str().expect(&format!("ERROR: unable to parse output path: {}", self.path.display()))
            .to_string()
    }

    pub fn to_relative(&self, path: &str) -> String {
        let path_buf = PathBuf::from(path);
        path_buf.strip_prefix(self.output_dir())
            .expect(&format!("ERROR: Unable to make path relative: {}", path))
            .to_str()
            .expect(&format!("ERROR: Unable to make path relative: {}", path))
            .to_string()
    }
}

#[derive(Clone, Deserialize, Default, Debug)]
pub struct GitsySettingsRepo {
    pub path: PathBuf,
    pub name: Option<String>,
    pub description: Option<String>,
    pub website: Option<String>,
    pub branch: Option<String>,
    pub asset_files: Option<Vec<String>>,
    pub render_markdown: Option<bool>,
    pub syntax_highlight: Option<bool>,
    pub syntax_highlight_theme: Option<String>,
    pub attributes: Option<BTreeMap<String, toml::Value>>,
    pub paginate_history: Option<usize>,
    pub paginate_branches: Option<usize>,
    pub paginate_tags: Option<usize>,
    pub limit_history: Option<usize>,
    pub limit_commits: Option<usize>,
    pub limit_branches: Option<usize>,
    pub limit_tags: Option<usize>,
    pub limit_tree_depth: Option<usize>,
    pub limit_file_size: Option<usize>,
    pub limit_repo_size: Option<usize>,
    pub limit_total_size: Option<usize>,
    pub limit_context: Option<usize>,
    pub limit_diffs: Option<usize>,
}

impl Hash for GitsySettingsRepo {
    fn hash<H: Hasher>(&self, state: &mut H) {
        self.path.hash(state);
    }
}
impl PartialEq for GitsySettingsRepo {
    fn eq(&self, other: &Self) -> bool {
        self.path == other.path
    }
}
impl Eq for GitsySettingsRepo {}

pub type GitsyRepoDescriptions = HashSet<GitsySettingsRepo>;

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
pub struct GitsySettings {
    pub recursive_repo_dirs: Option<Vec<PathBuf>>,
    pub site_name: Option<String>,
    pub site_url: Option<String>,
    pub site_description: Option<String>,
    pub asset_files: Option<Vec<String>>,
    pub branch: Option<String>,
    #[serde(rename(deserialize = "gitsy_templates"))]
    pub templates: GitsySettingsTemplates,
    #[serde(rename(deserialize = "gitsy_outputs"))]
    pub outputs: GitsySettingsOutputs,
    pub paginate_history: Option<usize>,
    pub paginate_branches: Option<usize>,
    pub paginate_tags: Option<usize>,
    pub limit_history: Option<usize>,
    pub limit_commits: Option<usize>,
    pub limit_branches: Option<usize>,
    pub limit_tags: Option<usize>,
    pub limit_tree_depth: Option<usize>,
    pub limit_file_size: Option<usize>,
    pub limit_repo_size: Option<usize>,
    pub limit_total_size: Option<usize>,
    pub limit_context: Option<usize>,
    pub limit_diffs: Option<usize>,
    pub render_markdown: Option<bool>,
    pub syntax_highlight: Option<bool>,
    pub syntax_highlight_theme: Option<String>,
    #[serde(rename(deserialize = "gitsy_extra"))]
    pub extra: Option<BTreeMap<String, toml::Value>>,
}

impl GitsySettings {
    pub fn new(cli: &GitsyCli) -> (GitsySettings, GitsyRepoDescriptions) {
        // Parse the known settings directly into their struct
        let toml = read_to_string(&cli.path).expect(&format!("Configuration file not found: {}", cli.path.display()));
        let mut settings: GitsySettings = toml::from_str(&toml).expect("Configuration file is invalid.");
        if cli.is_local {
            // removing the site URL falls back to using the local directory
            settings.site_url = None;
        }

        // Settings are valid, so let's move into the directory with the config file
        if cli.dir.to_str().unwrap_or_default().len() > 0 {
            // empty string means current directory
            std::env::set_current_dir(&cli.dir)
                .expect(&format!("Unable to set working directory to: {}", cli.dir.display()));
        }

        // Get a list of all remaining TOML "tables" in the file.
        // These are the user-supplied individual repositories.
        let reserved_keys = vec!["gitsy_templates", "gitsy_outputs", "gitsy_extra"];
        let settings_raw: HashMap<String, toml::Value> = toml::from_str(&toml).expect("blah");
        let table_keys: Vec<String> = settings_raw
            .iter()
            .filter_map(|x| match x.1.is_table() {
                true => match reserved_keys.contains(&x.0.as_str()) {
                    false => Some(x.0.clone()),
                    true => None,
                },
                false => None,
            })
            .collect();

        // Try to convert each unknown "table" into a repo struct, and
        // save the ones that are successful.  If no repo name is
        // specified, use the TOML table name.
        let mut repo_descriptions: HashSet<GitsySettingsRepo> = HashSet::new();
        macro_rules! global_to_repo {
            ($settings:ident, $repo:ident, $field:ident) => {
                if $repo.$field.is_none() {
                    $repo.$field = $settings.$field.clone()
                }
            };
        }
        for k in &table_keys {
            let v = settings_raw.get(k).unwrap();
            match toml::from_str::<GitsySettingsRepo>(&v.to_string()) {
                Ok(mut repo) => {
                    if repo.name.is_none() {
                        repo.name = Some(k.clone());
                    }
                    global_to_repo!(settings, repo, branch);
                    global_to_repo!(settings, repo, render_markdown);
                    global_to_repo!(settings, repo, syntax_highlight);
                    global_to_repo!(settings, repo, syntax_highlight_theme);
                    global_to_repo!(settings, repo, paginate_history);
                    global_to_repo!(settings, repo, paginate_branches);
                    global_to_repo!(settings, repo, paginate_tags);
                    global_to_repo!(settings, repo, limit_history);
                    global_to_repo!(settings, repo, limit_commits);
                    global_to_repo!(settings, repo, limit_branches);
                    global_to_repo!(settings, repo, limit_tags);
                    global_to_repo!(settings, repo, limit_tree_depth);
                    global_to_repo!(settings, repo, limit_file_size);
                    global_to_repo!(settings, repo, limit_repo_size);
                    global_to_repo!(settings, repo, limit_total_size);
                    global_to_repo!(settings, repo, limit_context);
                    global_to_repo!(settings, repo, limit_diffs);

                    repo_descriptions.insert(repo);
                }
                Err(e) => {
                    error!("Failed to parse repo [{}]: {:?}", k, e);
                }
            }
        }

        match &settings.recursive_repo_dirs {
            Some(dirs) => {
                for parent in dirs {
                    for dir in read_dir(parent).expect("Repo directory not found.") {
                        let dir = dir.expect("Repo contains invalid entries");
                        let name: String = dir.file_name().to_string_lossy().to_string();
                        repo_descriptions.insert(GitsySettingsRepo {
                            path: dir.path().clone(),
                            name: Some(name),
                            branch: settings.branch.clone(),
                            render_markdown: settings.render_markdown.clone(),
                            syntax_highlight: settings.syntax_highlight.clone(),
                            syntax_highlight_theme: settings.syntax_highlight_theme.clone(),
                            paginate_history: settings.paginate_history.clone(),
                            paginate_branches: settings.paginate_branches.clone(),
                            paginate_tags: settings.paginate_tags.clone(),
                            limit_history: settings.limit_history.clone(),
                            limit_commits: settings.limit_commits.clone(),
                            limit_branches: settings.limit_branches.clone(),
                            limit_tags: settings.limit_tags.clone(),
                            limit_tree_depth: settings.limit_tree_depth.clone(),
                            limit_file_size: settings.limit_file_size.clone(),
                            limit_repo_size: settings.limit_repo_size.clone(),
                            limit_total_size: settings.limit_total_size.clone(),
                            limit_context: settings.limit_context.clone(),
                            limit_diffs: settings.limit_diffs.clone(),
                            ..Default::default()
                        });
                    }
                }
            }
            _ => {}
        }

        if cli.repos.len() > 0 {
            repo_descriptions.clear();
            for dir in &cli.repos {
                let name: String = dir.file_name()
                    .expect(&format!("Invalid repository path: {}", dir.display()))
                    .to_string_lossy().to_string();
                repo_descriptions.insert(GitsySettingsRepo {
                    path: dir.clone(),
                    name: Some(name),
                    branch: settings.branch.clone(),
                    render_markdown: settings.render_markdown.clone(),
                    syntax_highlight: settings.syntax_highlight.clone(),
                    syntax_highlight_theme: settings.syntax_highlight_theme.clone(),
                    paginate_history: settings.paginate_history.clone(),
                    paginate_branches: settings.paginate_branches.clone(),
                    paginate_tags: settings.paginate_tags.clone(),
                    limit_history: settings.limit_history.clone(),
                    limit_commits: settings.limit_commits.clone(),
                    limit_branches: settings.limit_branches.clone(),
                    limit_tags: settings.limit_tags.clone(),
                    limit_tree_depth: settings.limit_tree_depth.clone(),
                    limit_file_size: settings.limit_file_size.clone(),
                    limit_repo_size: settings.limit_repo_size.clone(),
                    limit_total_size: settings.limit_total_size.clone(),
                    limit_context: settings.limit_context.clone(),
                    limit_diffs: settings.limit_diffs.clone(),
                    ..Default::default()
                });
            }
        }

        (settings, repo_descriptions)
    }

    pub fn paginate_history(&self) -> usize {
        match self.paginate_history.unwrap_or(usize::MAX) {
            x if x == 0 => usize::MAX,
            x => x,
        }
    }

    pub fn paginate_branches(&self) -> usize {
        match self.paginate_branches.unwrap_or(usize::MAX) {
            x if x == 0 => usize::MAX,
            x => x,
        }
    }

    pub fn paginate_tags(&self) -> usize {
        match self.paginate_tags.unwrap_or(usize::MAX) {
            x if x == 0 => usize::MAX,
            x => x,
        }
    }
}