use crate::{
    error, normal, normal_noln, loud, louder, loudest,
    git::{
        dir_listing,
        GitFile,
        GitRepo,
        GitsyMetadata,
        parse_repo,
    },
    settings::{
        GitsyCli,
        GitsyRepoDescriptions,
        GitsySettings,
        GitsySettingsRepo,
    },
    template::{
        DirFilter,
        FileFilter,
        TsDateFn,
        TsTimestampFn,
    },
    util::GitsyError,
};
use git2::{Repository, Error};
use rayon::prelude::*;
use std::cmp;
use std::fs::{File, create_dir};
use std::io::Write;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicUsize, Ordering};
use std::time::Instant;
use tera::{Context, Tera};

#[cfg(feature = "markdown")]
use pulldown_cmark::{html, Options, Parser as MdParser};

#[cfg(any(feature = "highlight", feature = "highlight_fast"))]
use syntect::{
    html::{ClassedHTMLGenerator, ClassStyle, css_for_theme_with_class_style},
    parsing::SyntaxSet,
    highlighting::ThemeSet,
    util::LinesWithEndings,
};

macro_rules! size_check {
    ($settings:ident, $cur:expr, $total:expr, $action:expr) => {
        let cur: usize = $cur;
        if cur > $settings.limit_repo_size.unwrap_or(usize::MAX) {
            $action;
        }
        let total: usize = $total;
        if total.saturating_add($cur) > $settings.limit_total_size.unwrap_or(usize::MAX) {
            $action;
        }
    }
}

pub struct GitsyGenerator {
    cli: GitsyCli,
    settings: GitsySettings,
    repo_descriptions: GitsyRepoDescriptions,
}

impl GitsyGenerator {
    pub fn new(cli: GitsyCli, settings: GitsySettings,
               repo_descriptions: GitsyRepoDescriptions) -> GitsyGenerator {
        GitsyGenerator {
            cli,
            settings,
            repo_descriptions,
        }
    }
    #[cfg(feature = "markdown")]
    fn parse_markdown(contents: &str) -> String {
        let mut options = Options::empty();
        options.insert(Options::ENABLE_STRIKETHROUGH);
        options.insert(Options::ENABLE_TABLES);
        let parser = MdParser::new_ext(contents, options);
        let mut html_output: String = String::with_capacity(contents.len() * 3 / 2);
        html::push_html(&mut html_output, parser);
        html_output
    }

    #[cfg(any(feature = "highlight", feature = "highlight_fast"))]
    fn syntax_highlight(contents: &str, extension: &str) -> String {
        let syntax_set = SyntaxSet::load_defaults_newlines();
        let syntax = match syntax_set.find_syntax_by_extension(extension) {
            Some(s) => s,
            _ => { return contents.to_string(); },
        };
        let mut html_generator = ClassedHTMLGenerator::new_with_class_style(syntax, &syntax_set, ClassStyle::Spaced);
        for line in LinesWithEndings::from(contents) {
            match html_generator.parse_html_for_line_which_includes_newline(line) {
                Ok(_) => {},
                Err(_) => {
                    error!("Warning: failed to apply syntax highlighting.");
                    return contents.to_string();
                },
            }
        }
        html_generator.finalize()
    }

    fn fill_file_contents(repo: &Repository, file: &GitFile, settings: &GitsySettingsRepo) -> Result<GitFile, Error> {
        let mut file = file.clone();
        if file.kind == "file" {
            let blob = repo.find_blob(git2::Oid::from_str(&file.id)?)?;
            file.contents = match blob.is_binary() {
                false => {
                    let path = Path::new(&file.path);
                    let cstr = String::from_utf8_lossy(blob.content()).to_string();
                    let (content, rendered, pre) = match path.extension() {
                        #[cfg(feature = "markdown")]
                        Some(x) if settings.render_markdown.unwrap_or(false) && x == "md" => {
                            loudest!(" - rendering Markdown in {}", path.display());
                            let (cstr, rendered, pre) = (GitsyGenerator::parse_markdown(&cstr), true, false);
                            (cstr, rendered, pre)
                        },
                        #[cfg(any(feature = "highlight", feature = "highlight_fast"))]
                        Some(x) if settings.syntax_highlight.unwrap_or(false) => {
                            loudest!(" - syntax highlighting {}", path.display());
                            (GitsyGenerator::syntax_highlight(&cstr, x.to_string_lossy().to_string().as_str()), true, true)
                        },
                        _ => (cstr, false, true),
                    };
                    file.contents_safe = rendered;
                    file.contents_preformatted = pre;
                    Some(content)
                },
                true => Some(format!("[Binary data ({} bytes)]", blob.content().len())),
            };
        }
        Ok(file)
    }

    fn write_rendered(path: &str, rendered: &str) -> usize {
        let mut file = File::create(path)
            .expect(&format!("Unable to write to output path: {}", path));
        file.write(rendered.as_bytes())
            .expect(&format!("Failed to save rendered html to path: {}", path));
        louder!(" - wrote file: {}", path);
        rendered.as_bytes().len()
    }

    fn tera_init(&self) -> Result<Tera, GitsyError> {
        let mut template_path = self.settings.templates.path.clone();
        template_path.push("**");
        template_path.push("*.html");
        let mut tera = Tera::new(&template_path.to_string_lossy().to_string())?;
        tera.register_filter("only_files", FileFilter{});
        tera.register_filter("only_dirs", DirFilter{});
        tera.register_function("ts_to_date", TsDateFn{});
        tera.register_function("ts_to_git_timestamp", TsTimestampFn{});
        Ok(tera)
    }

    pub fn generate(&self) -> Result<(), GitsyError> {
        let start_all = Instant::now();
        let tera = self.tera_init()?;

        // Create output directory
        let _ = create_dir(self.settings.outputs.path.to_str().expect("Output path invalid."));

        let generated_dt = chrono::offset::Local::now();
        let mut global_bytes = 0;
        let mut total_bytes = 0;
        let mut repos: Vec<GitRepo> = vec!();

        if self.repo_descriptions.len() == 0 {
            panic!("No Git repositories defined!  Please check your configuration file ({})",
                   self.cli.path.display());
        }

        // Sort the repositories by name
        let mut repo_vec: Vec<GitsySettingsRepo> = self.repo_descriptions.iter().cloned().collect();
        repo_vec.sort_by(|x,y| x.name.as_deref().map(|n| n.cmp(&y.name.as_deref().unwrap_or_default()))
                         .unwrap_or(cmp::Ordering::Equal));
        // Find the one with the longest name, for pretty printing
        let global_name = "repo list";
        let longest_repo_name = repo_vec.iter().fold(0, |acc, x| {
            cmp::max(acc, x.name.as_deref().map(|n| n.len()).unwrap_or(0))
        }).max(global_name.len());

        loudest!("Global settings:\n{:#?}", &self.settings);

        // Iterate over each repository, generating outputs
        for repo_desc in &repo_vec {
            loudest!("Repo settings:\n{:#?}", &repo_desc);
            let start_repo = Instant::now();
            let mut repo_bytes = 0;
            let name = repo_desc.name.as_deref().expect("A configured repository has no name!");

            let repo_path = match &repo_desc.path {
                url if url.starts_with("https://") ||
                    url.to_str().unwrap_or_default().contains("@") => {
                        if self.settings.outputs.cloned_repos.is_none() {
                            error!("ERROR: Found remote repo [{}], but `cloned_repos` directory not configured.", name);
                            continue;
                        };
                        let clone_path: PathBuf = [self.settings.outputs.cloned_repos.as_deref().unwrap(),
                                                   name].iter().collect();
                        match Repository::open(&clone_path) {
                            Ok(r) => {
                                // Repo already cloned, so update all refs
                                let refs: Vec<String> = r.references()
                                    .expect(&format!("Unable to enumerate references for repo [{}]", name))
                                    .map(|x| x.expect(&format!("Found invalid reference in repo [{}]", name))
                                         .name()
                                         .expect(&format!("Found unnamed reference in repo: [{}]", name))
                                         .to_string()).collect();
                                r.find_remote("origin")
                                    .expect(&format!("Clone of repo [{}] missing `origin` remote.", name))
                                    .fetch(&refs, None, None)
                                    .expect(&format!("Failed to fetch updates from remote repo [{}]", name));
                                clone_path.to_string_lossy().to_string()
                            },
                            Err(_) => {
                                let mut builder = git2::build::RepoBuilder::new();

                                // TODO: git2-rs's ssh support just doesn't seem to
                                // work.  It finds the repo, but fails to either
                                // decrypt or use the private key.
                                //
                                //if !url.starts_with("https://") {
                                //    use secrecy::ExposeSecret;
                                //    // this must be SSH, which needs credentials.
                                //    let mut callbacks = git2::RemoteCallbacks::new();
                                //    callbacks.credentials(|_url, username_from_url, _allowed_types| {
                                //        //git2::Cred::ssh_key_from_agent(username_from_url.unwrap())
                                //
                                //        let keyfile = format!("{}/.ssh/id_rsa", std::env::var("HOME").unwrap());
                                //        let passphrase = pinentry::PassphraseInput::with_default_binary().unwrap()
                                //            .with_description(&format!("Enter passphrase for SSH key {} (repo: {})",
                                //                                       keyfile, url.display()))
                                //            .with_prompt("Passphrase:")
                                //            .interact().unwrap();
                                //        git2::Cred::ssh_key(
                                //            username_from_url.unwrap(),
                                //            None,
                                //            Path::new(&keyfile),
                                //            Some(passphrase.expose_secret()),
                                //        )
                                //    });
                                //    let mut options = git2::FetchOptions::new();
                                //    options.remote_callbacks(callbacks);
                                //    builder.fetch_options(options);
                                //}
                                builder
                                    .bare(true)
                                    .clone(&url.to_string_lossy().to_string(), &clone_path)
                                    .expect(&format!("Failed to clone remote repo [{}]", name));
                                clone_path.to_string_lossy().to_string()
                            }
                        }
                    }
                dir => {
                    match dir.metadata() {
                        Ok(m) if m.is_dir() => {},
                        _ => {
                            error!("ERROR: local repository [{}]: directory not found: {}", name, dir.display());
                            continue;
                        },
                    }
                    dir.to_string_lossy().to_string()
                },
            };
            let repo = Repository::open(&repo_path).expect("Unable to find git repository.");
            let metadata = GitsyMetadata {
                full_name: repo_desc.name.clone(),
                description: repo_desc.description.clone(),
                website: repo_desc.website.clone(),
                clone: None,
                attributes: repo_desc.attributes.clone().unwrap_or_default(),
            };
            normal_noln!("[{}{}]... ", name, " ".repeat(longest_repo_name - name.len()));
            let summary = parse_repo(&repo, &name, &repo_desc, metadata).expect("Failed to analyze repo HEAD.");

            let mut local_ctx = Context::from_serialize(&summary).unwrap();
            if let Some(extra) = &self.settings.extra {
                local_ctx.try_insert("extra", extra).expect("Failed to add extra settings to template engine.");
            }
            if let Some(site_name) = &self.settings.site_name {
                local_ctx.insert("site_name", site_name);
            }
            if let Some(site_url) = &self.settings.site_url {
                local_ctx.insert("site_url", site_url);
            }
            if let Some(site_description) = &self.settings.site_description {
                local_ctx.insert("site_description", site_description);
            }
            local_ctx.insert("site_generated_ts", &generated_dt.timestamp());
            local_ctx.insert("site_generated_offset", &generated_dt.offset().local_minus_utc());

            if let Some(templ_file) = self.settings.templates.repo_summary.as_deref() {
                match tera.render(templ_file, &local_ctx) {
                    Ok(rendered) => {
                        repo_bytes += GitsyGenerator::write_rendered(&self.settings.outputs.repo_summary(Some(&summary), None), &rendered);
                    },
                    Err(x) => match x.kind {
                        _ => error!("ERROR: {:?}", x),
                    },
                }
            }

            for branch in &summary.branches {
                size_check!(repo_desc, repo_bytes, total_bytes, break);
                local_ctx.insert("branch", branch);
                if let Some(templ_file) = self.settings.templates.branch.as_deref() {
                    match tera.render(templ_file, &local_ctx) {
                        Ok(rendered) => {
                            repo_bytes += GitsyGenerator::write_rendered(&self.settings.outputs.branch(Some(&summary), Some(branch)), &rendered);
                        },
                        Err(x) => match x.kind {
                            _ => error!("ERROR: {:?}", x),
                        },
                    }
                }
                local_ctx.remove("branch");
            }

            for tag in &summary.tags {
                size_check!(repo_desc, repo_bytes, total_bytes, break);
                local_ctx.insert("tag", tag);
                if let Some(tagged_id) = tag.tagged_id.as_ref() {
                    if let Some(commit) = summary.commits.get(tagged_id) {
                        local_ctx.insert("commit", &commit);
                    }
                }
                if let Some(templ_file) = self.settings.templates.tag.as_deref() {
                    match tera.render(templ_file, &local_ctx) {
                        Ok(rendered) => {
                            repo_bytes += GitsyGenerator::write_rendered(&self.settings.outputs.tag(Some(&summary), Some(tag)), &rendered);
                        },
                        Err(x) => match x.kind {
                            _ => error!("ERROR: {:?}", x),
                        },
                    }
                }
                local_ctx.remove("tag");
                local_ctx.remove("commit");
            }

            for (_id, commit) in &summary.commits {
                size_check!(repo_desc, repo_bytes, total_bytes, break);
                local_ctx.try_insert("commit", &commit).expect("Failed to add commit to template engine.");
                if let Some(templ_file) = self.settings.templates.commit.as_deref() {
                    match tera.render(templ_file, &local_ctx) {
                        Ok(rendered) => {
                            repo_bytes += GitsyGenerator::write_rendered(&self.settings.outputs.commit(Some(&summary), Some(commit)), &rendered);
                        },
                        Err(x) => match x.kind {
                            _ => error!("ERROR: {:?}", x),
                        },
                    }
                }
                local_ctx.remove("commit");
            }

            #[cfg(any(feature = "highlight", feature = "highlight_fast"))]
            if self.settings.templates.file.is_some() {
                let ts = ThemeSet::load_defaults();
                let theme = ts.themes.get(repo_desc.syntax_highlight_theme.as_deref()
                                          .unwrap_or("base16-ocean.light")).expect("Invalid syntax highlighting theme specified.");
                let css: String = css_for_theme_with_class_style(theme, syntect::html::ClassStyle::Spaced)
                    .expect("Invalid syntax highlighting theme specified.");
                repo_bytes += GitsyGenerator::write_rendered(&self.settings.outputs.syntax_css(Some(&summary), None), css.as_str());
            }


            // TODO: parallelize the rest of the processing steps.  This one is
            // done first because syntax highlighting is very slow.
            let files: Vec<&GitFile> = summary.all_files.iter().filter(|x| x.kind == "file").collect();
            let atomic_bytes: AtomicUsize = AtomicUsize::new(repo_bytes);
            let _ = files.par_iter().fold(|| Some(0), |acc, file| {
                // These two have to be recreated.  Cloning the Tera context is expensive.
                let repo = Repository::open(&repo_path).expect("Unable to find git repository.");
                let mut local_ctx = local_ctx.clone();

                let mut local_bytes = 0;
                let cur_repo_bytes = atomic_bytes.load(Ordering::Relaxed);
                size_check!(repo_desc, cur_repo_bytes, total_bytes, return None);
                let file = match file.size < repo_desc.limit_file_size.unwrap_or(usize::MAX) {
                    true => GitsyGenerator::fill_file_contents(&repo, &file, &repo_desc).expect("Failed to parse file."),
                    false => (*file).clone(),
                };
                local_ctx.try_insert("file", &file).expect("Failed to add file to template engine.");
                if let Some(templ_file) = self.settings.templates.file.as_deref() {
                    match tera.render(templ_file, &local_ctx) {
                        Ok(rendered) => {
                            local_bytes = GitsyGenerator::write_rendered(&self.settings.outputs.file(Some(&summary), Some(&file)), &rendered);
                            atomic_bytes.fetch_add(local_bytes, Ordering::Relaxed);
                        },
                        Err(x) => match x.kind {
                            _ => error!("ERROR: {:?}", x),
                        },
                    }
                }
                local_ctx.remove("file");
                Some(acc.unwrap() + local_bytes)})
                .while_some() // allow short-circuiting if size limit is reached
                .sum::<usize>();
            repo_bytes = atomic_bytes.load(Ordering::Relaxed);

            for dir in summary.all_files.iter().filter(|x| x.kind == "dir") {
                size_check!(repo_desc, repo_bytes, total_bytes, break);
                if dir.tree_depth >= repo_desc.limit_tree_depth.unwrap_or(usize::MAX) - 1 {
                    continue;
                }
                let listing = dir_listing(&repo, &dir).expect("Failed to parse file.");
                local_ctx.try_insert("files", &listing).expect("Failed to add dir to template engine.");
                if let Some(templ_file) = self.settings.templates.dir.as_deref() {
                    match tera.render(templ_file, &local_ctx) {
                        Ok(rendered) => {
                            repo_bytes += GitsyGenerator::write_rendered(&self.settings.outputs.dir(Some(&summary), Some(dir)), &rendered);
                        },
                        Err(x) => match x.kind {
                            _ => error!("ERROR: {:?}", x),
                        },
                    }
                }
                local_ctx.remove("files");
            }

            if repo_desc.asset_files.is_some() {
                let target_dir = self.settings.outputs.repo_assets(Some(&summary), None);
                for src_file in repo_desc.asset_files.as_ref().unwrap() {
                    let src_file = PathBuf::from(repo_path.to_owned() + "/" + src_file);
                    let mut dst_file = PathBuf::from(&target_dir);
                    dst_file.push(src_file.file_name()
                                  .expect(&format!("Failed to copy repo asset file: {} ({})",
                                                   src_file.display(), repo_desc.name.as_deref().unwrap_or_default())));
                    std::fs::copy(&src_file, &dst_file)
                        .expect(&format!("Failed to copy repo asset file: {} ({})",
                                         src_file.display(), repo_desc.name.as_deref().unwrap_or_default()));
                    if let Ok(meta) = std::fs::metadata(dst_file) {
                        repo_bytes += meta.len() as usize;
                    }
                }
            }

            repos.push(summary);
            normal!("{}done in {:.2}s ({} bytes)",
                    match crate::util::VERBOSITY.load(Ordering::Relaxed) > 1 {
                        true => " - ",
                        _ => "",
                    },
                    start_repo.elapsed().as_secs_f32(), repo_bytes);
            total_bytes += repo_bytes;
            size_check!(repo_desc, 0, total_bytes, break); // break if total is exceeded
        }

        let start_global = Instant::now();
        normal_noln!("[{}{}]... ", global_name, " ".repeat(longest_repo_name - global_name.len()));
        let mut global_ctx = Context::new();
        global_ctx.try_insert("repos", &repos).expect("Failed to add repo to template engine.");
        if let Some(extra) = &self.settings.extra {
            global_ctx.try_insert("extra", extra).expect("Failed to add extra settings to template engine.");
        }
        if let Some(site_name) = &self.settings.site_name {
            global_ctx.insert("site_name", site_name);
        }
        if let Some(site_url) = &self.settings.site_url {
            global_ctx.insert("site_url", site_url);
        }
        if let Some(site_description) = &self.settings.site_description {
            global_ctx.insert("site_description", site_description);
        }
        global_ctx.insert("site_generated_ts", &generated_dt.timestamp());
        global_ctx.insert("site_generated_offset", &generated_dt.offset().local_minus_utc());

        if let Some(templ_file) = self.settings.templates.repo_list.as_deref() {
            match tera.render(templ_file, &global_ctx) {
                Ok(rendered) => {
                    global_bytes += GitsyGenerator::write_rendered(&self.settings.outputs.repo_list(None, None), &rendered);
                },
                Err(x) => match x.kind {
                    _ => error!("ERROR: {:?}", x),
                },
            }
        }

        if let Some(templ_file) = self.settings.templates.error.as_deref() {
            match tera.render(templ_file, &global_ctx) {
                Ok(rendered) => {
                    global_bytes += GitsyGenerator::write_rendered(&self.settings.outputs.error(None, None), &rendered);
                },
                Err(x) => match x.kind {
                    _ => error!("ERROR: {:?}", x),
                },
            }
        }

        if self.settings.asset_files.is_some() {
            let target_dir = self.settings.outputs.global_assets(None, None);
            for src_file in self.settings.asset_files.as_ref().unwrap() {
                let src_file = PathBuf::from(src_file);
                let mut dst_file = PathBuf::from(&target_dir);
                dst_file.push(src_file.file_name()
                              .expect(&format!("Failed to copy asset file: {}", src_file.display())));
                std::fs::copy(&src_file, &dst_file)
                    .expect(&format!("Failed to copy asset file: {}", src_file.display()));
                if let Ok(meta) = std::fs::metadata(dst_file) {
                    global_bytes += meta.len() as usize;
                }
            }
        }

        total_bytes += global_bytes;
        normal!("done in {:.2}s ({} bytes)", start_global.elapsed().as_secs_f32(), global_bytes);
        loud!("Wrote {} bytes in {:.2}s", total_bytes, start_all.elapsed().as_secs_f32());
        Ok(())
    }
}