use crate::conventional::changelog::Context;

use std::{collections::HashMap, io, str::FromStr};

use std::{collections::HashMap, str::FromStr};

impl ChangelogCommand {
    fn make_changelog_for(
        &self,
        config: &Config,
        writer: &mut ChangelogWriter<impl io::Write>,
        helper: &GitHelper,
        from_rev: &Rev<'_>,
        to_rev: &Rev<'_>,
    ) -> Result<(), Error> {
        // TODO: this should be a parameter

/// Transforms a range of commits to pass them to the changelog writer.
struct ChangeLogTransformer<'a> {
    group_types: HashMap<&'a str, &'a str>,
    config: &'a Config,
    git: &'a GitHelper,
}
impl<'a> ChangeLogTransformer<'a> {
    fn new(config: &'a Config, git: &'a GitHelper) -> Self {

        let mut revwalk = helper.revwalk()?;

        Self {
            config,
            group_types,
            git,
        }
    }
    fn transform(&self, from_rev: &Rev<'a>, to_rev: &Rev<'a>) -> Result<Context<'a>, Error> {
        let mut revwalk = self.git.revwalk()?;

            let to_commit = helper.ref_to_commit(from_rev.0)?;

            let to_commit = self.git.ref_to_commit(from_rev.0)?;

            .flat_map(|oid| helper.find_commit(oid).ok())

            .flat_map(|oid| self.git.find_commit(oid).ok())

                if let Some(section) = group_types.get(conv_commit.r#type.as_ref()) {

                if let Some(section) = self.group_types.get(conv_commit.r#type.as_ref()) {

        let mut builder = ContextBuilder::new(&config)?

        let mut builder = ContextBuilder::new(self.config)?

        let context = builder.build()?;
        writer.write_template(&context)?;
        Ok(())

        Ok(builder.build()?)

        let transformer = ChangeLogTransformer::new(&config, &helper);

                let mut versions = helper.versions_from(&v);

                let to_rev = versions.pop();
                match to_rev {
                    None => self.make_changelog_for(
                        &config,
                        &mut writer,
                        &helper,
                        &from_rev,
                        &Rev("", None),
                    )?,
                    Some(tav) => {
                        let mut rev = tav.into();
                        self.make_changelog_for(&config, &mut writer, &helper, &from_rev, &rev)?;
                        loop {
                            let from_rev = rev;
                            match versions.pop() {
                                None => {
                                    self.make_changelog_for(
                                        &config,
                                        &mut writer,
                                        &helper,
                                        &from_rev,
                                        &Rev("", None),
                                    )?;
                                    break;
                                }
                                Some(tav) => {
                                    rev = tav.into();
                                    self.make_changelog_for(
                                        &config,
                                        &mut writer,
                                        &helper,
                                        &from_rev,
                                        &rev,
                                    )?;
                                }
                            }
                        }
                    }

                let iter: Vec<Rev<'_>> = Some(from_rev)
                    .into_iter()
                    .chain(helper.versions_from(&v).into_iter().rev().map(|v| v.into()))
                    .chain(Some(Rev("", None)))
                    .collect();
                for w in iter.windows(2) {
                    let from = &w[0];
                    let to = &w[1];
                    let context = transformer.transform(from, to)?;
                    writer.write_template(&context)?;

            None => self.make_changelog_for(
                &config,
                &mut writer,
                &helper,
                &Rev("HEAD", None),
                &Rev("", None),
            )?,

            None => {
                let context = transformer.transform(&Rev("HEAD", None), &Rev("", None))?;
                writer.write_template(&context)?;
            }

    config: &'a Config,

            config,

use git2::{Commit, Error, Oid, Repository, Revwalk};

use git2::{Commit, Error, Object, Oid, Repository, Revwalk};

        if let Ok(oid) = repo.revparse_single(tag).and_then(|obj| {
            if let Some(tag) = obj.as_tag() {
                Ok(tag.target_id())
            } else {
                Ok(obj.id())
            }
        }) {

        if let Ok(oid) = repo
            .revparse_single(tag)
            .and_then(object_to_target_commit_id)
        {

}
fn object_to_target_commit_id(obj: Object<'_>) -> Result<Oid, Error> {
    if let Some(tag) = obj.as_tag() {
        Ok(tag.target_id())
    } else {
        Ok(obj.id())
    }