use crate::command::release::Options;
use anyhow::{anyhow, bail};
use bstr::ByteSlice;
use cargo_metadata::{
    camino::{Utf8Component, Utf8Path, Utf8PathBuf},
    DependencyKind, Metadata, Package,
};
use dia_semver::Semver;
use git_repository::{
    actor,
    hash::ObjectId,
    object,
    odb::{pack, Find, FindExt},
    refs::{
        file,
        file::loose::reference::peel,
        mutable::Target,
        packed,
        transaction::{Change, Create, RefEdit},
    },
    Repository,
};
use std::{collections::BTreeSet, convert::TryInto, path::PathBuf, process::Command, str::FromStr};

struct State {
    root: Utf8PathBuf,
    seen: BTreeSet<String>,
    repo: Repository,
    packed_refs: Option<packed::Buffer>,
}

impl State {
    fn new(repo_path: impl Into<PathBuf>) -> anyhow::Result<Self> {
        let root = repo_path.into();
        let repo = git_repository::discover(&root)?;
        let packed_refs = repo.refs.packed()?;
        Ok(State {
            root: root.try_into()?,
            seen: BTreeSet::new(),
            repo,
            packed_refs,
        })
    }
}

/// In order to try dealing with https://github.com/sunng87/cargo-release/issues/224 and also to make workspace
/// releases more selective.
pub fn release(options: Options, version_bump_spec: String, crates: Vec<String>) -> anyhow::Result<()> {
    if crates.is_empty() {
        bail!("Please provide at least one crate name which also is a workspace member");
    }
    let meta = cargo_metadata::MetadataCommand::new().exec()?;
    for crate_name in crates {
        if !is_workspace_member(&meta, &crate_name) {
            bail!("Package to release must be a workspace member: '{}'", crate_name);
        }
        release_depth_first(options, &meta, &crate_name, &version_bump_spec)?;
    }
    Ok(())
}

fn is_workspace_member(meta: &Metadata, crate_name: &str) -> bool {
    meta.packages
        .iter()
        .find(|p| p.name == crate_name)
        .map_or(false, |p| meta.workspace_members.iter().any(|m| m == &p.id))
}

fn release_depth_first(options: Options, meta: &Metadata, crate_name: &str, bump_spec: &str) -> anyhow::Result<()> {
    let mut state = State::new(std::env::current_dir()?)?;
    let mut names_to_publish = vec![crate_name.to_owned()];

    let mut index = 0;
    while let Some(crate_name) = names_to_publish.get(index) {
        let package = meta
            .packages
            .iter()
            .find(|p| &p.name == crate_name)
            .ok_or_else(|| anyhow!("workspace member must be a listed package: '{}'", crate_name))?;
        for dependency in package.dependencies.iter().filter(|d| d.kind == DependencyKind::Normal) {
            if state.seen.contains(&dependency.name) || !is_workspace_member(meta, &dependency.name) {
                continue;
            }
            state.seen.insert(dependency.name.clone());
            names_to_publish.push(dependency.name.clone());
        }
        index += 1;
    }

    for crate_name in names_to_publish.iter().rev() {
        let package = meta
            .packages
            .iter()
            .find(|p| &p.name == crate_name)
            .expect("crate still there");

        if needs_release(package, &state)? {
            let (new_version, commit_id) = perform_release(meta, package, options, bump_spec, &state)?;

            let tag_name = format!("{}-{}", package.name, new_version);
            if options.dry_run {
                log::info!("Won't create tag {}", tag_name);
            } else {
                for tag in state
                    .repo
                    .refs
                    .transaction()
                    .prepare(
                        Some(RefEdit {
                            change: Change::Update {
                                log: Default::default(),
                                mode: Create::Only,
                                new: Target::Peeled(commit_id),
                            },
                            name: format!("refs/tags/{}", tag_name).try_into()?,
                            deref: false,
                        }),
                        git_lock::acquire::Fail::Immediately,
                    )?
                    .commit(&actor::Signature::empty())?
                {
                    log::info!("created tag {}", tag.name.as_bstr());
                }
            }
        } else {
            log::info!(
                "{} v{}  - skipped release as it didn't change",
                package.name,
                package.version
            );
        }
    }

    Ok(())
}

fn perform_release(
    meta: &Metadata,
    package: &Package,
    options: Options,
    bump_spec: &str,
    state: &State,
) -> anyhow::Result<(Semver, ObjectId)> {
    let new_version = bump_version(&package.version.to_string(), bump_spec)?;
    log::info!("{} v{} will be released", package.name, new_version);
    let commit_id = edit_manifest_and_fixup_dependent_crates(meta, package, &new_version, options, state)?;

    publish_crate(package, options)?;
    Ok((new_version, commit_id))
}

fn publish_crate(package: &Package, Options { dry_run, allow_dirty }: Options) -> anyhow::Result<()> {
    let max_attempts = 3;
    for attempt in 1..=max_attempts {
        let mut c = Command::new("cargo");
        c.arg("publish");

        if allow_dirty {
            c.arg("--allow-dirty");
        }
        c.arg("--manifest-path").arg(&package.manifest_path);
        log::info!("About to run {:?}", c);
        if dry_run || c.status()?.success() {
            break;
        } else if attempt == max_attempts {
            bail!("Could not successfully execute 'cargo publish' even ")
        } else {
            log::warn!(
                "'cargo publish' run {} failed but we retry up to {} times to rule out flakiness",
                attempt,
                max_attempts
            );
        }
    }
    Ok(())
}

fn edit_manifest_and_fixup_dependent_crates(
    meta: &Metadata,
    package: &Package,
    new_version: &Semver,
    Options { dry_run, allow_dirty }: Options,
    state: &State,
) -> anyhow::Result<ObjectId> {
    if !allow_dirty {
        assure_clean_working_tree()?;
    }
    log::trace!("Preparing {} for version update", package.manifest_path);
    let mut package_manifest_lock =
        git_lock::File::acquire_to_update_resource(&package.manifest_path, git_lock::acquire::Fail::Immediately, None)?;
    let mut packages_to_fix = meta
        .workspace_members
        .iter()
        .filter(|id| *id != &package.id)
        .map(|id| {
            meta.packages
                .iter()
                .find(|p| &p.id == id)
                .expect("workspace members are in packages")
        })
        .filter(|p| p.dependencies.iter().any(|dep| dep.name == package.name))
        .map(|p| {
            log::trace!("Preparing {} for dependency version update", p.manifest_path);
            git_lock::File::acquire_to_update_resource(&p.manifest_path, git_lock::acquire::Fail::Immediately, None)
                .map(|l| (p, l))
        })
        .collect::<Result<Vec<_>, _>>()?;

    let new_version = new_version.to_string();
    set_manifest_version(package, &new_version, &mut package_manifest_lock)?;
    for (package_to_update, out) in packages_to_fix.iter_mut() {
        update_package_dependency(package_to_update, &package.name, &new_version, out)?;
    }

    if dry_run {
        log::info!("Won't write changed manifests in dry-run mode");
        Ok(ObjectId::null_sha1())
    } else {
        log::info!("Committing changes to manifests");
        package_manifest_lock.commit()?;
        for (_, lock) in packages_to_fix {
            lock.commit()?;
        }
        refresh_cargo_lock(package)?;
        commit_changes(format!("Release {}-{}", package.name, new_version), state)
    }
}

pub fn refresh_cargo_lock(package: &Package) -> anyhow::Result<()> {
    cargo_metadata::MetadataCommand::new()
        .manifest_path(&package.manifest_path)
        .exec()?;
    Ok(())
}

fn assure_clean_working_tree() -> anyhow::Result<()> {
    let tracked_changed = !Command::new("git")
        .arg("diff")
        .arg("HEAD")
        .arg("--exit-code")
        .arg("--name-only")
        .status()?
        .success();
    if tracked_changed {
        bail!("Detected working tree changes. Please commit beforehand as otherwise these would be committed as part of manifest changes.")
    }

    let has_untracked = !Command::new("git")
        .arg("ls-files")
        .arg("--exclude-standard")
        .arg("--others")
        .output()?
        .stdout
        .as_slice()
        .trim()
        .is_empty();

    if has_untracked {
        bail!("Found untracked files which would possibly be packaged when publishing.")
    }
    Ok(())
}

fn commit_changes(message: impl AsRef<str>, state: &State) -> anyhow::Result<ObjectId> {
    // TODO: replace with gitoxide one day
    if !Command::new("git")
        .arg("commit")
        .arg("-am")
        .arg(message.as_ref())
        .status()?
        .success()
    {
        bail!("Failed to commit changed manifests");
    }
    Ok(state
        .repo
        .refs
        .loose_find_existing("HEAD")?
        .peel_to_id_in_place(&state.repo.refs, state.packed_refs.as_ref(), peel::none)?
        .to_owned())
}

fn update_package_dependency(
    package_to_update: &Package,
    name_to_find: &str,
    new_version: &str,
    mut out: impl std::io::Write,
) -> anyhow::Result<()> {
    let manifest = std::fs::read_to_string(&package_to_update.manifest_path)?;
    let mut doc = toml_edit::Document::from_str(&manifest)?;
    for dep_type in &["dependencies", "dev-dependencies", "build-dependencies"] {
        if let Some(name_table) = doc
            .as_table_mut()
            .get_mut(dep_type)
            .and_then(|deps| deps.as_table_mut())
            .and_then(|deps| deps.get_mut(name_to_find).and_then(|name| name.as_inline_table_mut()))
        {
            log::info!(
                "Updated {} dependency in {} crate to version {}",
                name_to_find,
                package_to_update.name,
                new_version
            );
            *name_table.get_or_insert("version", new_version) = toml_edit::Value::from(new_version);
        }
    }
    out.write_all(doc.to_string_in_original_order().as_bytes())?;

    Ok(())
}

fn set_manifest_version(package: &Package, new_version: &str, mut out: impl std::io::Write) -> anyhow::Result<()> {
    let manifest = std::fs::read_to_string(&package.manifest_path)?;
    let mut doc = toml_edit::Document::from_str(&manifest)?;
    doc["package"]["version"] = toml_edit::value(new_version);
    log::info!("Updated {} to version {}", package.name, new_version);
    out.write_all(doc.to_string_in_original_order().as_bytes())?;
    Ok(())
}

fn bump_version(version: &str, bump_spec: &str) -> anyhow::Result<Semver> {
    let v = Semver::parse(version).map_err(|err| std::io::Error::new(std::io::ErrorKind::Other, err.to_string()))?;
    Ok(match bump_spec {
        "major" => v.new_major(),
        "minor" => v.new_minor(),
        "patch" => v.new_patch(),
        _ => bail!("Invalid version specification: '{}'", bump_spec),
    }
    .expect("no overflow"))
}

fn needs_release(package: &Package, state: &State) -> anyhow::Result<bool> {
    let version_tag_name = format!("{}-v{}", package.name, package.version);
    let mut tag_ref = match state.repo.refs.find(&version_tag_name, state.packed_refs.as_ref())? {
        None => {
            log::info!(
                "Package {} wasn't tagged with {} yet and thus needs a release",
                package.name,
                version_tag_name
            );
            return Ok(true);
        }
        Some(r) => r,
    };
    let repo_relative_crate_dir = package
        .manifest_path
        .parent()
        .expect("parent of a file is always present")
        .strip_prefix(&state.root)
        .expect("workspace members are releative to the root directory");

    let target = peel_ref_fully(&mut state.repo.refs.find_existing("HEAD", None)?, state)?;
    let released_target = peel_ref_fully(&mut tag_ref, state)?;

    let mut buf = Vec::new();

    let current_dir_id = find_directory_id_in_tree(
        repo_relative_crate_dir,
        resolve_tree_id_from_ref_target(target, &state.repo, &mut buf)?,
        &state.repo,
        &mut buf,
    )?;
    let released_dir_id = find_directory_id_in_tree(
        repo_relative_crate_dir,
        resolve_tree_id_from_ref_target(released_target, &state.repo, &mut buf)?,
        &state.repo,
        &mut buf,
    )?;

    Ok(released_dir_id != current_dir_id)
}

fn find_directory_id_in_tree(
    path: &Utf8Path,
    id: ObjectId,
    repo: &Repository,
    buf: &mut Vec<u8>,
) -> anyhow::Result<ObjectId> {
    let mut tree_id = None::<ObjectId>;

    for component in path.components() {
        match component {
            Utf8Component::Normal(c) => {
                let mut tree_iter = repo
                    .odb
                    .find_existing(tree_id.take().unwrap_or(id), buf, &mut pack::cache::Never)?
                    .into_tree_iter()
                    .expect("tree");
                tree_id = tree_iter
                    .find_map(|e| {
                        let e = e.expect("tree parseable");
                        (e.filename == c).then(|| e.oid)
                    })
                    .map(ToOwned::to_owned);
                if tree_id.is_none() {
                    break;
                }
            }
            _ => panic!(
                "only normal components are expected in relative manifest paths: '{}'",
                path
            ),
        }
    }

    tree_id.ok_or_else(|| anyhow!("path '{}' didn't exist in tree {}", path, id))
}

fn peel_ref_fully(reference: &mut file::Reference<'_>, state: &State) -> anyhow::Result<ObjectId> {
    reference
        .peel_to_id_in_place(&state.repo.refs, state.packed_refs.as_ref(), |oid, buf| {
            state
                .repo
                .odb
                .find(oid, buf, &mut pack::cache::Never)
                .map(|r| r.map(|obj| (obj.kind, obj.data)))
        })
        .map_err(Into::into)
}

/// Note that borrowchk doesn't like us to return an immutable, decoded tree which we would otherwise do. Chalk/polonius could allow that,
/// preventing a duplicate lookup.
fn resolve_tree_id_from_ref_target(mut id: ObjectId, repo: &Repository, buf: &mut Vec<u8>) -> anyhow::Result<ObjectId> {
    let mut cursor = repo.odb.find_existing(id, buf, &mut pack::cache::Never)?;
    loop {
        match cursor.kind {
            object::Kind::Tree => return Ok(id),
            object::Kind::Commit => {
                id = cursor.into_commit_iter().expect("commit").tree_id().expect("id");
                cursor = repo.odb.find_existing(id, buf, &mut pack::cache::Never)?;
            }
            object::Kind::Tag | object::Kind::Blob => {
                bail!(
                    "A ref ultimately points to a blob or tag {} but we need a tree, peeling takes care of tags",
                    id
                )
            }
        }
    }
}