)


def test_update_project(
    repo_with_placeholder_committed: Repo,
):
    repo = repo_with_placeholder_committed
    expect_data: CookiecutterRemoteTemplateData = dict(name="woo", key="it works")
    with change_directory_to(GENERATED_REPO_DIR):
        fxt("init")
        fxt(
            [
                "add",
                "source",
                COOKIECUTTER_REMOTE_URL,
                "--version",
                COOKIECUTTER_REMOTE_VERSION_1,
            ]
        )
        fxt(["add", "output", COOKIECUTTER_REMOTE_NAME], input_data=expect_data)
        _assert_project_files_are_correct(
            expect_data=expect_data, version=COOKIECUTTER_REMOTE_VERSION_1
        )
        _assert_config_is_correct(
            expect_data=expect_data, version=COOKIECUTTER_REMOTE_VERSION_1
        )
        fxt(["update", "--no-input"])
        # First update does nothing, because version is at target version
        _assert_project_files_are_correct(
            expect_data=expect_data, version=COOKIECUTTER_REMOTE_VERSION_1
        )
        _assert_config_is_correct(
            expect_data=expect_data, version=COOKIECUTTER_REMOTE_VERSION_1
        )
        # Now update the target version
        # TODO: replace with cli command to update target version once it exists
        config_path = GENERATED_REPO_DIR / "flexlate.json"
        config = FlexlateConfig.load(config_path)
        source = config.template_sources[0]
        source.target_version = COOKIECUTTER_REMOTE_VERSION_2
        config.save()
        stage_and_commit_all(
            repo, "Update target version for cookiecutter to version 2"
        )
        # Now update should go to new version
        fxt(["update", "--no-input"])

    _assert_project_files_are_correct(expect_data=expect_data)
    _assert_config_is_correct(expect_data=expect_data)

    project_config_path = GENERATED_REPO_DIR / "flexlate-project.json"
    _assert_project_config_is_correct(project_config_path, user=False)


def _assert_project_files_are_correct(
    root: Path = GENERATED_REPO_DIR,
    expect_data: Optional[CookiecutterRemoteTemplateData] = None,
    version: str = COOKIECUTTER_REMOTE_VERSION_2,
):
    data: CookiecutterRemoteTemplateData = expect_data or dict(name="abc", key="value")
    header = get_header_for_cookiecutter_remote_template(version)
    out_path = root / data["name"] / f"{data['name']}.txt"
    assert out_path.exists()
    content = out_path.read_text()
    assert content == f"{header}{data['key']}"


def _assert_template_sources_config_is_correct(
    config_path: Path = GENERATED_REPO_DIR / "flexlate.json",
    version: str = COOKIECUTTER_REMOTE_VERSION_2,
):
    assert config_path.exists()
    config = FlexlateConfig.load(config_path)

    if not branch_exists(temp_repo, branch_name):
        # Now create the new branch
        log.debug(
            f"Creating {branch_name} in the temporary repo from branch {base_branch_name}"
        )
        # TODO: should this be use_branch_name and not base_branch_name?
        checkout_template_branch(temp_repo, branch_name, base_branch_name)

    return temp_repo

            seen_sources.add(source.name)
        return list(sources_with_templates.values())

    def move_applied_template(
        self,
        template_name: str,
        config_path: Path,
        new_config_path: Path,
        project_root: Path = Path("."),
        out_root: Path = Path("."),
        orig_project_root: Path = Path("."),
    ):
        config = self.load_config(project_root=project_root, adjust_applied_paths=False)
        child_config = _get_or_create_child_config_by_path(config, config_path)
        template_index, _ = self._find_applied_template(
            template_name,
            config_path,
            project_root=project_root,
            out_root=out_root,
            orig_project_root=orig_project_root,
            config=config,
            adjust_applied_paths=False,
        )
        applied_template = child_config.applied_templates.pop(template_index)
        new_child_config = _get_or_create_child_config_by_path(config, new_config_path)
        new_child_config.applied_templates.append(applied_template)
        self.save_config(config)

    def move_template_source(
        self,
        template_name: str,
        config_path: Path,
        new_config_path: Path,
        project_root: Path = Path("."),
    ):
        config = self.load_config(project_root=project_root, adjust_applied_paths=False)
        child_config = _get_or_create_child_config_by_path(config, config_path)
        template_index, _ = self._find_template_source(
            template_name,
            config_path,
            project_root=project_root,
            config=config,
        )
        template_source = child_config.template_sources.pop(template_index)
        new_child_config = _get_or_create_child_config_by_path(config, new_config_path)
        new_child_config.template_sources.append(template_source)
        self.save_config(config)

    def _get_applied_templates_and_sources_with_local_add_mode(
        self,
        project_root: Path = Path("."),
        config: Optional[FlexlateConfig] = None,
    ) -> List[AppliedTemplateWithSource]:
        config = config or self.load_config(project_root=project_root)

        return [
            atws
            for atws in self.get_applied_templates_with_sources(
                project_root=project_root, config=config
            )
            if atws.applied_template.add_mode == AddMode.LOCAL
        ]

    def move_local_applied_templates_if_necessary(
        self,
        project_root: Path = Path("."),
        orig_project_root: Path = Path("."),
        renderer: MultiRenderer = MultiRenderer(),
    ):
        config = self.load_config(project_root=project_root)
        applied_templates_with_sources = (
            self._get_applied_templates_and_sources_with_local_add_mode(
                project_root=project_root, config=config
            )
        )
        for atwc in applied_templates_with_sources:
            source = atwc.source
            if source.is_local_template:
                # Move source back to orig project so that relative template
                # paths can be resolved
                source.path = str(
                    location_relative_to_new_parent(
                        Path(source.path), project_root, orig_project_root, project_root
                    ).resolve()
                )
            template = source.to_template()
            if template.render_relative_root_in_output == Path("."):
                # Should not need to move as config will not be in a subdirectory
                continue
            renderable = Renderable.from_applied_template_with_source(atwc)
            new_relative_out_root = Path(
                renderer.render_string(
                    str(template.render_relative_root_in_output), renderable
                )
            )
            if template.render_relative_root_in_output == new_relative_out_root:
                # No need to move, render relative root was not a templated path
                continue

            orig_config_path = atwc.applied_template._config_file_location

            render_root = (
                orig_config_path.parent / atwc.applied_template._orig_root
            ).resolve()
            new_config_path = render_root / new_relative_out_root / "flexlate.json"
            if orig_config_path == new_config_path:
                # No need to move, still in the same location
                continue

            # Must have different location now, move it
            # TODO: more efficient algorithm for updating locations of applied templates
            #  Currently it needs to find the template twice
            self.move_applied_template(
                atwc.source.name,
                orig_config_path,
                new_config_path,
                project_root=project_root,
                out_root=atwc.applied_template._orig_root,
                orig_project_root=orig_project_root,
            )


def _get_child_config_by_path(config: FlexlateConfig, path: Path) -> FlexlateConfig:
    for child_config in config.child_configs:

            print(f"- {path} (directory)")
            if nested:
                display_contents_of_all_files_in_folder(path, nested)


def assert_dir_trees_are_equal(dir1: Union[str, Path], dir2: Union[str, Path]):
    """
    Compare two directories recursively. Files in each directory are
    assumed to be equal if their names and contents are equal.

    See: https://stackoverflow.com/a/6681395/6276321

    @param dir1: First directory path
    @param dir2: Second directory path

    @return: True if the directory trees are the same and
        there were no errors while accessing the directories or files,
        False otherwise.
    """

    dirs_cmp = filecmp.dircmp(dir1, dir2)
    if (
        len(dirs_cmp.left_only) > 0
        or len(dirs_cmp.right_only) > 0
        or len(dirs_cmp.funny_files) > 0
    ):
        pass
        # TODO: figure out why this fails in CI but not local

        # raise AssertionError(
        #     f"lefy only: {dirs_cmp.left_only}. right only: {dirs_cmp.right_only}. funny files: {dirs_cmp.funny_files}"
        # )
    (_, mismatch, errors) = filecmp.cmpfiles(
        dir1, dir2, dirs_cmp.common_files, shallow=False
    )
    if len(mismatch) > 0 or len(errors) > 0:
        raise AssertionError(f"mismatch: {mismatch}. errors: {errors}")
    for common_dir in dirs_cmp.common_dirs:
        new_dir1 = os.path.join(dir1, common_dir)
        new_dir2 = os.path.join(dir2, common_dir)
        assert_dir_trees_are_equal(new_dir1, new_dir2)

import uuid
from enum import Enum
from pathlib import Path
from typing import Optional, List, Sequence

from git import Repo, Commit  # type: ignore
from pydantic import BaseModel, Field, UUID4, validator

from flexlate.exc import (
    CannotParseCommitMessageFlexlateTransaction,
    LastCommitWasNotByFlexlateException,
    TransactionMismatchBetweenBranchesException,
    InvalidNumberOfTransactionsException,
    TooFewTransactionsException,
    ExpectedMergeCommitException,
    CannotFindCorrectMergeParentException,
    UserChangesWouldHaveBeenDeletedException,
    MergeCommitIsNotMergingAFlexlateTransactionException,
    CannotFindMergeForTransactionException,
)
from flexlate.ext_git import (
    reset_current_branch_to_commit,
    get_commits_between_two_commits,
)
from flexlate.template_data import TemplateData

FLEXLATE_TRANSACTION_COMMIT_DIVIDER = (
    "\n\n-------------------BEGIN FLEXLATE TRANSACTION-------------------\n"
)


class TransactionType(str, Enum):
    ADD_SOURCE = "add source"
    ADD_OUTPUT = "add output"
    REMOVE_SOURCE = "remove source"
    REMOVE_OUTPUT = "remove output"
    UPDATE = "update"


class FlexlateTransaction(BaseModel):
    type: TransactionType
    target: Optional[str] = None
    out_root: Optional[Path] = None
    data: Optional[Sequence[TemplateData]] = None
    id: UUID4 = Field(default_factory=lambda: uuid.uuid4())

    @validator("data", pre=True)
    def cast_data_into_sequence(cls, v):
        if isinstance(v, dict):
            return [v]
        return v

    @classmethod
    def parse_commit_message(cls, message: str) -> "FlexlateTransaction":
        parts = message.split(FLEXLATE_TRANSACTION_COMMIT_DIVIDER)
        if len(parts) != 2:
            raise CannotParseCommitMessageFlexlateTransaction(
                f"Could not parse commit message {message}. After splitting "
                f"on the divider, got {len(parts)} parts instead of 2"
            )
        _, transaction_part = parts
        return cls.parse_raw(transaction_part)

    @property
    def commit_message(self) -> str:
        return self.json(indent=2)


def create_transaction_commit_message(
    commit_message: str, transaction: FlexlateTransaction
) -> str:
    return (
        commit_message
        + FLEXLATE_TRANSACTION_COMMIT_DIVIDER
        + transaction.commit_message
    )


def reset_last_transaction(
    repo: Repo,
    transaction: FlexlateTransaction,
    merged_branch_name: str,
    template_branch_name: str,
):
    last_transaction = find_last_transaction_from_commit(
        repo.commit(), merged_branch_name, template_branch_name
    )
    if last_transaction.id != transaction.id:
        raise TransactionMismatchBetweenBranchesException(
            f"Found mismatching transaction ids: {last_transaction.id} and {transaction.id}"
        )
    earliest_commit = find_earliest_commit_that_was_part_of_transaction(
        repo, last_transaction, merged_branch_name, template_branch_name
    )

    is_template_branch = repo.active_branch.name == template_branch_name
    if is_template_branch:
        # On template branch, the only commits are flexlate transactions.
        # Therefore can just get the parent to find the commit before the
        # transaction started
        before_transaction_commit = _get_parent_commit(earliest_commit)
    else:
        # On output/user branch, typically the only commits are merging flexlate transactions
        # and user changes. So find the commit that merged this transaction,
        # then use its parent.
        try:
            merge_commit = find_earliest_merge_commit_for_transaction(
                repo, transaction, merged_branch_name, template_branch_name
            )
        except CannotFindMergeForTransactionException:
            # This is likely because the user has not made any changes in the repo yet,
            # and so the merges from the template branch are always fast-forwards.
            # In this case, it is a mirror of the template branch and so we should use
            # that logic
            before_transaction_commit = _get_parent_commit(earliest_commit)
        else:
            before_transaction_commit = (
                _get_non_flexlate_transaction_parent_from_flexlate_merge_commit(
                    merge_commit, merged_branch_name, template_branch_name
                )
            )

    assert_that_all_commits_between_two_are_flexlate_transactions_or_merges(
        repo,
        before_transaction_commit,
        repo.commit(),
        merged_branch_name,
        template_branch_name,
    )
    reset_current_branch_to_commit(repo, before_transaction_commit)


def find_last_transaction_from_commit(
    commit: Commit, merged_branch_name: str, template_branch_name: str
) -> FlexlateTransaction:
    if _is_flexlate_merge_commit(commit, merged_branch_name, template_branch_name):
        parent = _get_flexlate_transaction_parent_from_flexlate_merge_commit(
            commit, merged_branch_name, template_branch_name
        )
        return find_last_transaction_from_commit(
            parent, merged_branch_name, template_branch_name
        )
    return FlexlateTransaction.parse_commit_message(commit.message)


def find_earliest_merge_commit_for_transaction(
    repo: Repo,
    transaction: FlexlateTransaction,
    merged_branch_name: str,
    template_branch_name: str,
) -> Commit:
    # Walk back through commit tree, searching for the appropriate commit
    return _search_commit_tree_for_earliest_merge_commit_for_transaction(
        repo.commit(), transaction, merged_branch_name, template_branch_name
    )


def _search_commit_tree_for_earliest_merge_commit_for_transaction(
    commit: Commit,
    transaction: FlexlateTransaction,
    merged_branch_name: str,
    template_branch_name: str,
):
    # TODO: Better strategy for finding earliest merge commit for transaction
    #  The current strategy requires searching until the beginning of history.
    #  Add early stopping when hitting a user commit or different flexlate transaction
    search_commits = [commit]
    found_commits: List[Commit] = []
    # Breadth-first search
    while len(search_commits) > 0:
        this_commit = search_commits.pop(0)
        if _is_flexlate_merge_commit(
            this_commit, merged_branch_name, template_branch_name
        ):
            merge_transaction = _get_transaction_underlying_merge_commit(this_commit)
            if transaction.id == merge_transaction.id:
                found_commits.append(this_commit)
        search_commits.extend(list(this_commit.parents))

    if len(found_commits) == 0:
        raise CannotFindMergeForTransactionException(
            f"Could not find the merge commit for transaction {transaction}"
        )

    # Since BFS was used, last found commit should be the earliest
    return found_commits[-1]


def _get_transaction_underlying_merge_commit(commit: Commit) -> FlexlateTransaction:
    for parent in commit.parents:
        try:
            return FlexlateTransaction.parse_commit_message(parent.message)
        except CannotParseCommitMessageFlexlateTransaction:
            continue
    raise MergeCommitIsNotMergingAFlexlateTransactionException(
        f"Commit {commit.hexsha}: {commit.message}"
    )


def assert_last_commit_was_in_a_flexlate_transaction(
    repo: Repo, merged_branch_name: str, template_branch_name: str
):
    last_commit = repo.commit()
    if _is_flexlate_merge_commit(last_commit, merged_branch_name, template_branch_name):
        return
    if isinstance(last_commit.message, bytes):
        raise LastCommitWasNotByFlexlateException(
            f"Last commit was not made by flexlate, message is bytes"
        )
    try:

        FlexlateTransaction.parse_commit_message(last_commit.message)
    except CannotParseCommitMessageFlexlateTransaction as e:
        raise LastCommitWasNotByFlexlateException(
            f"Last commit was not made by flexlate: {last_commit.message}"
        ) from e


def assert_has_at_least_n_transactions(
    repo: Repo, n: int, merged_branch_name: str, template_branch_name: str
):
    if n < 0:
        raise InvalidNumberOfTransactionsException(
            "Number of transactions must be positive"
        )
    assert_last_commit_was_in_a_flexlate_transaction(
        repo, merged_branch_name, template_branch_name
    )
    if n == 1:
        return
    last_commit = repo.commit()
    num_to_verify = n

    def too_few_transactions():
        # Have hit the end but have not finished verifying, therefore there are too few transactions
        raise TooFewTransactionsException(
            f"Desired to undo {n} transactions but only found {n - num_to_verify}"
        )

    for _ in range(num_to_verify):
        if _is_flexlate_merge_commit(
            last_commit, merged_branch_name, template_branch_name
        ):
            last_commit = _get_flexlate_transaction_parent_from_flexlate_merge_commit(
                last_commit, merged_branch_name, template_branch_name
            )
        if isinstance(last_commit.message, bytes):
            # Flexlate never commits with binary messages
            return too_few_transactions()
        try:
            transaction = FlexlateTransaction.parse_commit_message(last_commit.message)
        except CannotParseCommitMessageFlexlateTransaction:
            return too_few_transactions()
        earliest_commit = _return_commit_if_begin_of_transaction_else_get_parent(
            last_commit, transaction, merged_branch_name, template_branch_name
        )
        num_to_verify -= 1
        if num_to_verify <= 0:
            return
        try:
            last_commit = _get_parent_commit(earliest_commit)
        except (HitInitialCommit, HitMergeCommit):
            return too_few_transactions()


def assert_that_all_commits_between_two_are_flexlate_transactions_or_merges(
    repo: Repo,
    start: Commit,
    end: Commit,
    merged_branch_name: str,
    template_branch_name: str,
):
    between_commits = get_commits_between_two_commits(repo, start, end)
    for commit in between_commits:
        if _is_flexlate_merge_commit(commit, merged_branch_name, template_branch_name):
            continue
        try:
            FlexlateTransaction.parse_commit_message(commit.message)
        except CannotParseCommitMessageFlexlateTransaction:
            raise UserChangesWouldHaveBeenDeletedException(
                f"Commit {commit.hexsha}: {commit.message} would have been deleted "
                f"by the flexlate undo strategy. An extra check prevented it. "
                f"Please raise this as an issue on Github"
            )


def find_earliest_commit_that_was_part_of_transaction(
    repo: Repo,
    transaction: FlexlateTransaction,
    merged_branch_name: str,
    template_branch_name: str,
) -> Commit:
    return _return_commit_if_begin_of_transaction_else_get_parent(
        repo.commit(), transaction, merged_branch_name, template_branch_name
    )


def _return_commit_if_begin_of_transaction_else_get_parent(
    commit: Commit,
    transaction: FlexlateTransaction,
    merged_branch_name: str,
    template_branch_name: str,
) -> Commit:
    try:
        parent_commit = _get_parent_commit(commit)
    except HitInitialCommit:
        return commit
    except HitMergeCommit:
        parent_commit = _get_flexlate_transaction_parent_from_flexlate_merge_commit(
            commit, merged_branch_name, template_branch_name
        )
    try:
        commit_transaction = FlexlateTransaction.parse_commit_message(
            parent_commit.message
        )
    except CannotParseCommitMessageFlexlateTransaction:
        # Not a flexlate commit, so this must be the last in the transaction
        return commit

    if commit_transaction.id == transaction.id:
        # Parent is still in the same transaction. Recurse to find the original commit
        return _return_commit_if_begin_of_transaction_else_get_parent(
            parent_commit, transaction, merged_branch_name, template_branch_name
        )

    # It is a flexlate commit, but different transaction. Therefore return this commit
    return commit


class HitInitialCommit(Exception):
    pass


class HitMergeCommit(Exception):
    pass


def _get_parent_commit(commit: Commit) -> Commit:
    parents = commit.parents
    if len(parents) == 0:
        raise HitInitialCommit
    if len(parents) > 1:
        raise HitMergeCommit
    return parents[0]


def _get_flexlate_transaction_parent_from_flexlate_merge_commit(
    commit: Commit, merged_branch_name: str, template_branch_name: str
) -> Commit:
    if not _is_flexlate_merge_commit(commit, merged_branch_name, template_branch_name):
        raise ExpectedMergeCommitException("not a flexlate merge commit")
    if len(commit.parents) != 2:
        raise ExpectedMergeCommitException(f"has {len(commit.parents)} parents, not 2")
    flexlate_transaction_parents: List[Commit] = []
    for parent in commit.parents:
        try:
            FlexlateTransaction.parse_commit_message(parent.message)
            flexlate_transaction_parents.append(parent)
        except CannotParseCommitMessageFlexlateTransaction:
            pass
    if len(flexlate_transaction_parents) != 1:
        raise CannotFindCorrectMergeParentException(
            f"Cannot determine which of these commits is the flexlate transaction parent {flexlate_transaction_parents}"
        )
    return flexlate_transaction_parents[0]


def _get_non_flexlate_transaction_parent_from_flexlate_merge_commit(
    commit: Commit, merged_branch_name: str, template_branch_name: str
) -> Commit:
    if not _is_flexlate_merge_commit(commit, merged_branch_name, template_branch_name):
        raise ExpectedMergeCommitException("not a flexlate merge commit")
    if len(commit.parents) != 2:
        raise ExpectedMergeCommitException(f"has {len(commit.parents)} parents, not 2")
    non_flexlate_transaction_parents: List[Commit] = []
    for parent in commit.parents:
        try:
            FlexlateTransaction.parse_commit_message(parent.message)
        except CannotParseCommitMessageFlexlateTransaction:
            non_flexlate_transaction_parents.append(parent)
    if len(non_flexlate_transaction_parents) != 1:
        raise CannotFindCorrectMergeParentException(
            f"Cannot determine which of these commits is the non-flexlate transaction parent {non_flexlate_transaction_parents}"
        )
    return non_flexlate_transaction_parents[0]


def _is_flexlate_merge_commit(
    commit: Commit, merged_branch_name: str, template_branch_name: str
) -> bool:
    return (
        commit.message
        == f"Merge branch '{template_branch_name}' into {merged_branch_name}\n"
    )

from pathlib import Path

import pytest

from flexlate.exc import InvalidTemplatePathException
from flexlate.template_path import (
    is_repo_url,
    is_local_template,
    get_local_repo_path_and_name_cloning_if_repo_url,
)
from tests.config import GENERATED_FILES_DIR
from tests.dirutils import wipe_generated_folder
from tests.fixtures.repo_path import (
    repo_path_fixture,
    repo_path_non_ssh_fixture,
    RepoPathFixture,
)


def test_is_repo_url(repo_path_fixture: RepoPathFixture):
    assert is_repo_url(repo_path_fixture.path) == repo_path_fixture.is_repo_url


def test_is_local_path(repo_path_fixture: RepoPathFixture):
    assert is_local_template(repo_path_fixture.path) == repo_path_fixture.is_local_path


# TODO: figure out how to test cloning SSH urls
def test_get_local_repo_path_cloning_if_repo_url(
    repo_path_non_ssh_fixture: RepoPathFixture,
):
    repo_path_fixture = repo_path_non_ssh_fixture
    wipe_generated_folder()
    if not repo_path_fixture.is_repo_url and not repo_path_fixture.is_local_path:
        # Invalid path test
        with pytest.raises(InvalidTemplatePathException):
            get_local_repo_path_and_name_cloning_if_repo_url(
                repo_path_fixture.path, GENERATED_FILES_DIR
            )
        # Path was invalid so nothing else to check, end test
        return

    # Must be valid template path, local or remote
    for version in repo_path_fixture.versions:
        local_path, name = get_local_repo_path_and_name_cloning_if_repo_url(
            repo_path_fixture.path, version, GENERATED_FILES_DIR
        )
        assert name == repo_path_fixture.name
        if repo_path_fixture.is_local_path:
            assert local_path == Path(repo_path_fixture.path)
        elif repo_path_fixture.is_repo_url:
            assert local_path == GENERATED_FILES_DIR / repo_path_fixture.name / (
                version or repo_path_fixture.default_version
            )
            repo_path_fixture.assert_was_cloned_correctly(local_path, version)
        wipe_generated_folder()

            kwargs.update(target_version=self.target_version)
        if self.git_url is not None:
            kwargs.update(git_url=self.git_url)
        local_path: Path
        if self.git_url is not None:
            # TODO: Avoid unnecessary git repo cloning
            #  We already know that we have it by this point, but need to get the local path
            #  and the logic to resolve the version that may be None is entertwined with the
            #  cloning and local path determination
            local_path, _ = get_local_repo_path_and_name_cloning_if_repo_url(
                self.git_url, version=self.version
            )
        else:
            local_path = self.absolute_local_path

        template = finder.find(self.git_url or str(local_path), local_path, **kwargs)
        # Keep original template source path (may be relative), so that later when
        # updating templates, it can update the path without forcing it to be absolute

    branch.checkout()


def _get_initial_commit_sha(repo: Repo) -> str:
    return repo.git.rev_list("HEAD", max_parents=0)


def _get_initial_commit(repo: Repo) -> Commit:
    return repo.commit(_get_initial_commit_sha(repo))


def stage_and_commit_all(repo: Repo, commit_message: str):
    repo.git.add("-A")
    repo.git.commit("-m", commit_message)


def list_tracked_files(repo: Repo) -> Set[Path]:
    if repo.working_dir is None:
        raise ValueError("repo working dir should not be none")
    return _list_tracked_files(repo.tree(), Path(repo.working_dir))


def _list_tracked_files(tree: Tree, root_path: Path) -> Set[Path]:
    # TODO: Fix multiple iterations over files for git traverse
    #  For now just using a set to keep it working, but should optimize
    files: Set[Path] = set()
    for tree_or_blob in tree.traverse():
        if hasattr(tree_or_blob, "traverse"):
            # Got another tree
            tree = cast(Tree, tree_or_blob)
            files.update(_list_tracked_files(tree, root_path))
        else:
            # Got a blob
            blob = cast(Blob, tree_or_blob)
            files.add(root_path / Path(blob.path))
    return files


def delete_tracked_files_excluding_initial_commit(repo: Repo):
    if repo.working_dir is None:
        raise ValueError("repo working dir should not be none")
    initial_commit_files = _list_tracked_files(
        _get_initial_commit(repo).tree, Path(repo.working_dir)
    )
    for path in list_tracked_files(repo):
        if path not in initial_commit_files:
            os.remove(path)


def merge_branch_into_current(
    repo: Repo, branch_name: str, allow_conflicts: bool = True
):

    assert at.name == template.name
    assert at.version == template.version
    assert at.data == {"name": "abc", "key": "value"}
    assert at.root == template_root


# TODO: tests for different out roots
# TODO: test for adding to existing

class CopierFinder(TemplateFinder[CopierTemplate]):
    def find(self, path: str, local_path: Path, **template_kwargs) -> CopierTemplate:
        # TODO: determine why passing target_version through kwargs was not necessary for copier
        #  Had to do that for cookiecutter, but tests were passing without any changes here.
        git_version: Optional[str] = template_kwargs.get("version")
        custom_name: Optional[str] = template_kwargs.get("name")
        name = custom_name or local_path.name
        config = self.get_config(local_path)
        version = get_version_from_source_path(path, local_path) or git_version
        git_url = get_git_url_from_source_path(path, template_kwargs)
        return CopierTemplate(
            config,
            local_path,
            name=name,
            version=version,
            target_version=git_version,

            current_branch.checkout()
            merge_branch_into_current(repo, merged_branch_name)

            # TODO: Make CLI have a pause and resume capability
            #  We should be running these post actions below afterwards regardless of whether
            #  there was a merge conflict.

            # Current working directory or out root may have been deleted if it was a remove operation
            # and there was nothing else in the folder (git does not save folders without files)
            ensure_exists_folders = [cwd]
            for renderable in orig_renderables:
                ensure_exists_folders.append(
                    make_absolute_path_from_possibly_relative_to_another_path(
                        renderable.out_root, project_root
                    )
                )
            for folder in ensure_exists_folders:
                if not os.path.exists(folder):
                    os.makedirs(folder)

            # Folder may have been deleted again while switching branches, so
            # need to set cwd again
            os.chdir(cwd)

    def get_updates_for_templates(
        self,
        templates: Sequence[Template],

from enum import Enum
from typing import List, Final

import pytest
from git import Repo

from flexlate.ext_git import delete_local_branch
from tests.gitutils import reset_n_commits_without_checkout


class LocalBranchSituation(str, Enum):
    UP_TO_DATE = "up to date"
    DELETED = "deleted"
    OUT_OF_DATE = "out of date"

    def apply(self, repo: Repo, branch_name: str):
        apply_local_branch_situation(repo, branch_name, self)


all_local_branch_situations: Final[List[LocalBranchSituation]] = list(
    LocalBranchSituation
)


@pytest.fixture(scope="module", params=all_local_branch_situations)
def local_branch_situation(request) -> LocalBranchSituation:
    return request.param


# TODO: see if there is a better way to structure multiple parameterized fixtures
#  that actually resolve to the same value
@pytest.fixture(scope="module", params=all_local_branch_situations)
def template_branch_situation(request) -> LocalBranchSituation:
    return request.param


@pytest.fixture(scope="module", params=all_local_branch_situations)
def output_branch_situation(request) -> LocalBranchSituation:
    return request.param


def apply_local_branch_situation(
    repo: Repo, branch_name: str, situation: LocalBranchSituation
):
    if situation == LocalBranchSituation.UP_TO_DATE:
        return
    if situation == LocalBranchSituation.DELETED:
        return delete_local_branch(repo, branch_name)
    if situation == LocalBranchSituation.OUT_OF_DATE:
        return reset_n_commits_without_checkout(repo, branch_name)
    raise NotImplementedError(f"no handling for local branch situation {situation}")

                out_root=expanded_out_root,
            )
        else:
            # TODO: restructure the current path logic into _add_operation_via_branches
            #  as it will also be needed for other operations.
            # Commit changes for local and project
            cwd = Path(os.getcwd())
            absolute_out_root = out_root.absolute()
            def make_dirs_add_applied_template():
                # Need to ensure that both cwd and out root exist on the template branch
                for p in [cwd, absolute_out_root]:
                    if not p.exists():
                        p.mkdir(parents=True)
                # If cwd was deleted when switching branches, need to navigate back there
                # or os.getcwd will throw a FileNotExistsError (which also breaks path.absolute())
                os.chdir(cwd)

                config_manager.add_applied_template(
                    template,
                    config_path,
                    data=data,
                    project_root=project_root,
                    out_root=expanded_out_root,
                )

            _add_operation_via_branches(
                make_dirs_add_applied_template,
                repo,
                _add_template_commit_message(
                    template, out_root, Path(repo.working_dir)

from typing import Optional

from git import Repo, GitCommandError

from flexlate.branch_update import (
    get_flexlate_branch_name_for_feature_branch,
    abort_merge_and_reset_flexlate_branches,
)
from flexlate.cli_utils import confirm_user
from flexlate.constants import DEFAULT_MERGED_BRANCH_NAME, DEFAULT_TEMPLATE_BRANCH_NAME
from flexlate.ext_git import (
    fast_forward_branch_without_checkout,
    temp_repo_that_pushes_to_branch,
    repo_has_merge_conflicts,
    get_branch_sha,
    delete_local_branch,
)
from flexlate.styles import (
    print_styled,
    INFO_STYLE,
    ACTION_REQUIRED_STYLE,
    styled,
    QUESTION_STYLE,
    ALERT_STYLE,
    SUCCESS_STYLE,
)


class Merger:
    def merge_flexlate_branches(
        self,
        repo: Repo,
        branch_name: Optional[str] = None,
        delete: bool = True,
        merged_branch_name: str = DEFAULT_MERGED_BRANCH_NAME,
        template_branch_name: str = DEFAULT_TEMPLATE_BRANCH_NAME,
    ):
        feature_branch = branch_name or repo.active_branch.name
        flexlate_feature_merged_branch_name = (
            get_flexlate_branch_name_for_feature_branch(
                feature_branch, merged_branch_name
            )
        )
        flexlate_feature_template_branch_name = (
            get_flexlate_branch_name_for_feature_branch(
                feature_branch, template_branch_name
            )
        )

        # Save the status of the flexlate branches. We may need to roll back to this state
        # if the user aborts the merge
        current_branch = repo.active_branch
        merged_branch_sha = get_branch_sha(repo, merged_branch_name)
        template_branch_sha = get_branch_sha(repo, template_branch_name)

        print_styled(
            f"Merging {flexlate_feature_template_branch_name} to {template_branch_name}",
            INFO_STYLE,
        )
        try:
            fast_forward_branch_without_checkout(
                repo, template_branch_name, flexlate_feature_template_branch_name
            )
        except GitCommandError as e:
            # TODO: make sure it's the right git error
            # Could not fast forward. Must do a merge in a temp repo and have user resolve any conflicts
            with temp_repo_that_pushes_to_branch(  # type: ignore
                repo,
                branch_name=template_branch_name,
                base_branch_name=template_branch_name,
                additional_branches=(flexlate_feature_template_branch_name,),
            ) as temp_repo:
                temp_repo.git.merge(flexlate_feature_template_branch_name)  # type: ignore
                if repo_has_merge_conflicts(temp_repo):
                    print_styled(
                        f"Encountered merge conflicts while merging "
                        f"{flexlate_feature_template_branch_name} into {template_branch_name}",
                        INFO_STYLE,
                    )
                    print_styled(
                        f"Flexlate uses a temporary repo for this merge. "
                        f"Please resolve conflicts in {temp_repo.working_dir}",  # type: ignore
                        ACTION_REQUIRED_STYLE,
                    )
                    handled_conflicts = confirm_user(
                        styled(
                            "Successfully handled conflicts? n to abort", QUESTION_STYLE
                        )
                    )
                    if not handled_conflicts:
                        # Have only done work in a temp dir so far, so can just abort
                        print_styled("Aborting merge.", ALERT_STYLE)
                        return
        print_styled(
            f"Successfully merged {flexlate_feature_template_branch_name} to {template_branch_name}",
            SUCCESS_STYLE,
        )

        # Now merge the merged branch in the main repo
        try:
            fast_forward_branch_without_checkout(
                repo, merged_branch_name, flexlate_feature_merged_branch_name
            )
        except GitCommandError as e:
            # TODO: make sure it's the right git error
            # Could not fast forward. Must do a merge and have user resolve any conflicts
            merged_branch = repo.branches[merged_branch_name]  # type: ignore
            merged_branch.checkout()
            repo.git.merge(flexlate_feature_merged_branch_name)
            if repo_has_merge_conflicts(temp_repo):
                print_styled(
                    f"Encountered merge conflicts while merging "
                    f"{flexlate_feature_template_branch_name} into {template_branch_name}",
                    INFO_STYLE,
                )
                print_styled(f"Please resolve the conflicts", ACTION_REQUIRED_STYLE)
                handled_conflicts = confirm_user(
                    styled("Successfully handled conflicts? n to abort", QUESTION_STYLE)
                )
                if not handled_conflicts:
                    # Time ot abort, but need to reset the state of the branches
                    print_styled("Aborting merge.", ALERT_STYLE)
                    abort_merge_and_reset_flexlate_branches(
                        repo,
                        current_branch,
                        merged_branch_sha=merged_branch_sha,
                        template_branch_sha=template_branch_sha,
                        merged_branch_name=merged_branch_name,
                        template_branch_name=template_branch_name,
                    )

                    return

        print_styled(
            f"Successfully merged {flexlate_feature_merged_branch_name} to {merged_branch_name}",
            SUCCESS_STYLE,
        )

        if not delete:
            return

        # Handle delete
        print_styled(
            f"Deleting flexlate feature branches {flexlate_feature_template_branch_name} and {flexlate_feature_merged_branch_name}",
            INFO_STYLE,
        )
        delete_local_branch(repo, flexlate_feature_template_branch_name)
        delete_local_branch(repo, flexlate_feature_merged_branch_name)
        print_styled(f"Successfully deleted flexlate feature branches", SUCCESS_STYLE)

    _assert_project_config_is_correct(project_config_path, user=False)


def _assert_root_template_output_is_correct(
    template_source: TemplateSourceFixture,
    after_version_update: bool = False,
    after_data_update: bool = False,
    num_template_sources: int = 1,
    template_source_index: int = 0,
):
    version = (
        template_source.version_2 if after_version_update else template_source.version_1
    )
    input_data = (
        template_source.update_input_data
        if after_data_update
        else template_source.input_data
    )
    at_config_path = (
        GENERATED_REPO_DIR
        / template_source.evaluated_render_relative_root_in_output_creator(input_data)
        / "flexlate.json"
    )
    _assert_project_files_are_correct(
        expect_data=input_data,
        version=version,
        template_source_type=template_source.type,
    )
    _assert_config_is_correct(
        at_config_path=at_config_path,
        expect_applied_template_root=template_source.expect_local_applied_template_path,
        expect_data=input_data,
        version=version,
        template_source_type=template_source.type,
        name=template_source.name,
        url=template_source.url,
        path=template_source.path,
        render_relative_root_in_output=template_source.render_relative_root_in_output,
        render_relative_root_in_template=template_source.render_relative_root_in_template,
        num_template_sources=num_template_sources,
        template_source_index=template_source_index,
    )


def test_update_one_template(
    flexlates: FlexlateFixture,
    repo_with_placeholder_committed: Repo,
):
    fxt = flexlates.flexlate
    repo = repo_with_placeholder_committed
    no_input = flexlates.type == FlexlateType.APP

    def assert_root_template_output_is_correct(
        template_source: TemplateSourceFixture,
        after_version_update: bool = False,
        after_data_update: bool = False,
        num_template_sources: int = 2,
        template_source_index: int = 0,
    ):
        _assert_root_template_output_is_correct(
            template_source,
            after_version_update,
            after_data_update,
            num_template_sources=num_template_sources,
            template_source_index=template_source_index,
        )

    non_update_template_source: TemplateSourceFixture = COOKIECUTTER_REMOTE_FIXTURE
    with template_source_with_temp_dir_if_local_template(
        COPIER_LOCAL_FIXTURE
    ) as template_source:
        with change_directory_to(GENERATED_REPO_DIR):
            fxt.init_project()
            # Add both template sources and outputs in the main directory at version 1
            for i, ts in enumerate([template_source, non_update_template_source]):
                fxt.add_template_source(ts.path, target_version=ts.version_1)
                fxt.apply_template_and_add(
                    ts.name, data=ts.input_data, no_input=no_input
                )
                num_template_sources = i + 1
                assert_root_template_output_is_correct(
                    ts,
                    num_template_sources=num_template_sources,
                    template_source_index=i,
                )

            # First update does nothing, because version is at target version
            # When using app, it will throw an error
            if flexlates.type == FlexlateType.APP:
                with pytest.raises(TriedToCommitButNoChangesException) as excinfo:
                    fxt.update([template_source.name], no_input=True)
                assert "update did not make any new changes" in str(excinfo.value)
            else:
                # When using CLI stub, it will throw a CLIRunnerException
                with pytest.raises(CLIRunnerException) as excinfo:
                    fxt.update([template_source.name], no_input=True)
                assert "update did not make any new changes" in str(excinfo.value)

            assert_root_template_output_is_correct(template_source)
            assert_root_template_output_is_correct(
                non_update_template_source, template_source_index=1
            )

            # Now update by just passing new data, should change the output
            # even though the version has not changed
            fxt.update(
                [template_source.name],
                data=[template_source.update_input_data],
                no_input=no_input,
            )
            assert_root_template_output_is_correct(
                template_source, after_data_update=True
            )
            # Other template unaffected
            assert_root_template_output_is_correct(
                non_update_template_source, template_source_index=1
            )

            # Now update the target version
            # TODO: replace with cli command to update target version once it exists
            config_path = GENERATED_REPO_DIR / "flexlate.json"
            config = FlexlateConfig.load(config_path)
            source = config.template_sources[0]
            source.target_version = template_source.version_2
            config.save()
            stage_and_commit_all(
                repo, f"Update target version for {template_source.name} to version 2"
            )

            # Make changes to update local templates to new version (no-op for remote templates)
            template_source.version_migrate_func(template_source.url_or_absolute_path)

            # Now update should go to new version
            fxt.update([template_source.name], no_input=True)

        assert_root_template_output_is_correct(
            template_source, after_version_update=True, after_data_update=True
        )
        # Other template unaffected
        assert_root_template_output_is_correct(
            non_update_template_source, template_source_index=1
        )

        project_config_path = GENERATED_REPO_DIR / "flexlate-project.json"
        _assert_project_config_is_correct(project_config_path, user=False)


@patch.object(appdirs, "user_config_dir", lambda name: GENERATED_FILES_DIR)
@pytest.mark.parametrize("user", [False, True])
def test_remove_template_source(

    repo = repo_with_default_flexlate_project
    with change_directory_to(GENERATED_REPO_DIR):
        fxt.add_template_source(
            COPIER_REMOTE_URL, target_version=COPIER_REMOTE_VERSION_1
        )
        # TODO: Allow updating template sources even when there are no applied templates
        #  It should not be necessary to add this template for the update cli integration tests to pass
        #  Need to rework the process of getting updates, right now it relies on there being applied templates
        fxt.apply_template_and_add(COPIER_REMOTE_NAME, no_input=True)
    yield repo

from typing import Optional

from git import Repo, GitCommandError

from flexlate.branch_update import (
    get_flexlate_branch_name_for_feature_branch,
    abort_merge_and_reset_flexlate_branches,
)
from flexlate.cli_utils import confirm_user
from flexlate.constants import DEFAULT_MERGED_BRANCH_NAME, DEFAULT_TEMPLATE_BRANCH_NAME
from flexlate.ext_git import (
    fast_forward_branch_without_checkout,
    temp_repo_that_pushes_to_branch,
    repo_has_merge_conflicts,
    get_branch_sha,
    delete_local_branch,
)
from flexlate.styles import (
    print_styled,
    INFO_STYLE,
    ACTION_REQUIRED_STYLE,
    styled,
    QUESTION_STYLE,
    ALERT_STYLE,
    SUCCESS_STYLE,
)


class Merger:
    def merge_flexlate_branches(
        self,
        repo: Repo,
        branch_name: Optional[str] = None,
        delete: bool = True,
        merged_branch_name: str = DEFAULT_MERGED_BRANCH_NAME,
        template_branch_name: str = DEFAULT_TEMPLATE_BRANCH_NAME,
    ):
        feature_branch = branch_name or repo.active_branch.name
        flexlate_feature_merged_branch_name = (
            get_flexlate_branch_name_for_feature_branch(
                feature_branch, merged_branch_name
            )
        )
        flexlate_feature_template_branch_name = (
            get_flexlate_branch_name_for_feature_branch(
                feature_branch, template_branch_name
            )
        )

        # Save the status of the flexlate branches. We may need to roll back to this state
        # if the user aborts the merge
        current_branch = repo.active_branch
        merged_branch_sha = get_branch_sha(repo, merged_branch_name)
        template_branch_sha = get_branch_sha(repo, template_branch_name)

        print_styled(
            f"Merging {flexlate_feature_template_branch_name} to {template_branch_name}",
            INFO_STYLE,
        )
        try:
            fast_forward_branch_without_checkout(
                repo, template_branch_name, flexlate_feature_template_branch_name
            )
        except GitCommandError as e:
            # TODO: make sure it's the right git error
            # Could not fast forward. Must do a merge in a temp repo and have user resolve any conflicts
            with temp_repo_that_pushes_to_branch(  # type: ignore
                repo,
                branch_name=template_branch_name,
                base_branch_name=template_branch_name,
                additional_branches=(flexlate_feature_template_branch_name,),
            ) as temp_repo:
                temp_repo.git.merge(flexlate_feature_template_branch_name)  # type: ignore
                if repo_has_merge_conflicts(temp_repo):
                    print_styled(
                        f"Encountered merge conflicts while merging "
                        f"{flexlate_feature_template_branch_name} into {template_branch_name}",
                        INFO_STYLE,
                    )
                    print_styled(
                        f"Flexlate uses a temporary repo for this merge. "
                        f"Please resolve conflicts in {temp_repo.working_dir}",  # type: ignore
                        ACTION_REQUIRED_STYLE,
                    )
                    handled_conflicts = confirm_user(
                        styled(
                            "Successfully handled conflicts? n to abort", QUESTION_STYLE
                        )
                    )
                    if not handled_conflicts:
                        # Have only done work in a temp dir so far, so can just abort
                        print_styled("Aborting merge.", ALERT_STYLE)
                        return
        print_styled(
            f"Successfully merged {flexlate_feature_template_branch_name} to {template_branch_name}",
            SUCCESS_STYLE,
        )

        # Now merge the merged branch in the main repo
        try:
            fast_forward_branch_without_checkout(
                repo, merged_branch_name, flexlate_feature_merged_branch_name
            )
        except GitCommandError as e:
            # TODO: make sure it's the right git error
            # Could not fast forward. Must do a merge and have user resolve any conflicts
            merged_branch = repo.branches[merged_branch_name]  # type: ignore
            merged_branch.checkout()
            repo.git.merge(flexlate_feature_merged_branch_name)
            if repo_has_merge_conflicts(temp_repo):
                print_styled(
                    f"Encountered merge conflicts while merging "
                    f"{flexlate_feature_template_branch_name} into {template_branch_name}",
                    INFO_STYLE,
                )
                print_styled(f"Please resolve the conflicts", ACTION_REQUIRED_STYLE)
                handled_conflicts = confirm_user(
                    styled("Successfully handled conflicts? n to abort", QUESTION_STYLE)
                )
                if not handled_conflicts:
                    # Time ot abort, but need to reset the state of the branches
                    print_styled("Aborting merge.", ALERT_STYLE)
                    abort_merge_and_reset_flexlate_branches(
                        repo,
                        current_branch,
                        merged_branch_sha=merged_branch_sha,
                        template_branch_sha=template_branch_sha,
                        merged_branch_name=merged_branch_name,
                        template_branch_name=template_branch_name,
                    )

                    return

        print_styled(
            f"Successfully merged {flexlate_feature_merged_branch_name} to {merged_branch_name}",
            SUCCESS_STYLE,
        )

        if not delete:
            return

        # Handle delete
        print_styled(
            f"Deleting flexlate feature branches {flexlate_feature_template_branch_name} and {flexlate_feature_merged_branch_name}",
            INFO_STYLE,
        )
        delete_local_branch(repo, flexlate_feature_template_branch_name)
        delete_local_branch(repo, flexlate_feature_merged_branch_name)
        print_styled(f"Successfully deleted flexlate feature branches", SUCCESS_STYLE)

            raise ValueError("repo working dir should not be none")

        project_root = Path(repo.working_dir)
        template = config_manager.get_template_by_name(
            template_name, project_root=project_root
        )

        # Determine location of config
        # Need to get renderable to render path in case it is templated
        # TODO: can use get all renderables
        renderables = config_manager.get_renderables_for_updates(
            config_manager.get_no_op_updates(project_root=project_root),
            project_root=project_root,
        )
        if len(renderables) == 0:
            raise CannotRemoveAppliedTemplateException(
                f"Cannot find any applied template with name {template_name} "
                f"because there are no applied templates"
            )
        renderable = renderables[0]
        new_relative_out_root = Path(
            renderer.render_string(
                str(template.render_relative_root_in_output), renderable
            )
        )
        full_local_config_out_root = out_root / new_relative_out_root
        config_path = determine_config_path_from_roots_and_add_mode(
            full_local_config_out_root, project_root, add_mode
        )

        expanded_out_root = get_expanded_out_root(
            out_root, project_root, template.render_relative_root_in_output, add_mode
        )

        if add_mode == AddMode.USER:
            # No need to commit config changes for user

        child_config.template_sources.append(source)
        self.save_config(config)

    def remove_template_source(
        self,
        template_name: str,
        config_path: Path,
        project_root: Path = Path("."),
    ):
        config = self.load_config(project_root=project_root)
        if self._applied_template_exists_in_project(
            template_name, project_root=project_root, config=config
        ):
            # TODO: Improve error message for can't remove template source
            #  When can't remove template source due to existing applied template, determine paths where
            #  the existing applied templates are to inform the user what needs to be removed
            raise CannotRemoveTemplateSourceException(
                f"Cannot remove template source {template_name} as it has existing outputs"
            )

        child_config = _get_or_create_child_config_by_path(config, config_path)
        template_index: Optional[int] = None
        for i, template_source in enumerate(child_config.template_sources):
            if template_source.name == template_name:
                template_index = i
                break
        if template_index is None:
            raise CannotRemoveTemplateSourceException(
                f"Cannot find any template source with name {template_name}"
            )
        child_config.template_sources.pop(template_index)
        self.save_config(config)

    def _applied_template_exists_in_project(
        self,
        template_name: str,
        project_root: Path = Path("."),
        config: Optional[FlexlateConfig] = None,
    ):
        config = config or self.load_config(project_root=project_root)
        for child_config in config.child_configs:
            for applied_template in child_config.applied_templates:
                if applied_template.name == template_name:
                    return True
        return False

    def add_applied_template(
        self,
        template: Template,

    if not _branch_exists(temp_repo, branch_name):
        # Now create the new branch
        checkout_template_branch(temp_repo, branch_name, base_branch_name)

    return temp_repo


def _clone_specific_branches_from_local_repo(
    repo: Repo,
    out_dir: Path,
    branch_names: Sequence[str],
    checkout_branch: str,
    base_checkout_branch: str,
) -> Repo:
    temp_repo = Repo.init(out_dir)
    valid_branches = [name for name in branch_names if _branch_exists(repo, name)]
    branch_arguments = list(
        itertools.chain(*[["-t", branch] for branch in valid_branches])
    )
    temp_repo.git.remote("add", "-f", *branch_arguments, "origin", repo.working_dir)
    for branch in valid_branches:
        # TODO: is there a way to set up remote tracking branches without checkout?
        temp_repo.git.checkout("-t", f"origin/{branch}")

    if _branch_exists(repo, checkout_branch):
        temp_repo.branches[checkout_branch].checkout()  # type: ignore
    else:
        # Create the branch
        checkout_template_branch(repo, checkout_branch, base_checkout_branch)
    return temp_repo

                ),
                TemplateSource.from_template(
                    # It is actually useless to put target version in a local template
                    # TODO: throw an error when user tries to target version for a local template
                    local_template,
                    target_version=COOKIECUTTER_ONE_VERSION,
                ),

import json

import pytest
from git import Repo

from flexlate.config import FlexlateConfig
from flexlate.ext_git import stage_and_commit_all
from flexlate.main import Flexlate
from flexlate.path_ops import change_directory_to
from tests.config import (
    GENERATED_REPO_DIR,
    COOKIECUTTER_REMOTE_URL,
    COOKIECUTTER_REMOTE_VERSION_1,
)
from tests.fixtures.git import *

fxt = Flexlate()


@pytest.fixture
def repo_with_default_flexlate_project(repo_with_placeholder_committed: Repo) -> Repo:
    repo = repo_with_placeholder_committed
    with change_directory_to(GENERATED_REPO_DIR):
        fxt.init_project()
    yield repo


@pytest.fixture
def repo_with_copier_remote_version_one(
    repo_with_default_flexlate_project: Repo,
) -> Repo:
    repo = repo_with_default_flexlate_project
    with change_directory_to(GENERATED_REPO_DIR):
        fxt.add_template_source(
            COOKIECUTTER_REMOTE_URL, target_version=COOKIECUTTER_REMOTE_VERSION_1
        )
    yield repo


@pytest.fixture
def repo_with_copier_remote_version_one_and_no_target_version(
    repo_with_copier_remote_version_one: Repo,
) -> Repo:
    repo = repo_with_copier_remote_version_one
    # TODO: replace with cli command to update target version once it exists
    config_path = GENERATED_REPO_DIR / "flexlate.json"
    config = FlexlateConfig.load(config_path)
    source = config.template_sources[0]
    source.target_version = None
    config.save()
    stage_and_commit_all(repo, f"Remove target version for copier remote")
    yield repo


@pytest.fixture
def repo_with_copier_remote_version_one_no_target_version_and_will_have_a_conflict_on_update(
    repo_with_copier_remote_version_one_and_no_target_version: Repo,
) -> Repo:
    repo = repo_with_copier_remote_version_one_and_no_target_version
    # Reformat the flexlate config to cause a conflict
    config_path = GENERATED_REPO_DIR / "flexlate.json"
    config_data = json.loads(config_path.read_text())
    config_path.write_text(json.dumps(config_data, indent=4))
    stage_and_commit_all(repo, "Reformat flexlate config to cause a conflict on update")
    yield repo

                kwargs.update(version=source.target_version)
            for template in source_with_templates.templates:
                new_template = finder.find(str(source.update_location), **kwargs)
                # TODO: Create new templates rather than updating existing ones
                #  This would eliminate issues from partial updates of templates as new attributes are added.
                #  I think the logic is set up this way because order of the templates matters.
                if template.version != new_template.version:
                    # Template needs to be upgraded
                    # As finder already updates the local files, just update the template object
                    template.update_from_template(new_template)


def _commit_message(renderables: Sequence[Renderable]) -> str:

# TODO: get version statically inside package by restructuring template
import pkg_resources


def get_flexlate_version() -> str:
    return pkg_resources.get_distribution("flexlate").version

        )

    # TODO: list template sources, list applied templates, remove applied templates and sources
    # TODO: Update target versions in template sources

                f"no handling for template type {self.type} in creating template from source"
            )
        kwargs = dict(name=self.name)
        version = version or self.version
        if version is not None:
            kwargs.update(version=version)
        # TODO: Can we remove target_version from templates?
        if self.target_version is not None:
            kwargs.update(target_version=self.target_version)
        if self.git_url is not None:

    class Config:
        arbitrary_types_allowed = True

    def to_applied_template(
        self, project_root: Path = Path("."), adjust_root: bool = True
    ) -> AppliedTemplateConfig:
        config = FlexlateConfig.load(self.config_location)
        applied_template = config.applied_templates[self.index]
        if applied_template.name != self.template.name:
            raise CannotFindAppliedTemplateException(
                f"could not find applied template for name {self.template.name} "
                f"and index {self.index} in config {self.config_location}"
            )
        # Update the data if it is supplied in the update
        if self.data:
            applied_template.data = self.data
        if adjust_root:
            # Because this config may not be at the project root, adjust the path as if it was
            absolute_orig_root = (
                applied_template.root
                if applied_template.root.is_absolute()
                else (
                    self.config_location.parent.resolve() / applied_template.root
                ).resolve()
            )
            new_root = Path(os.path.relpath(absolute_orig_root, project_root))
            applied_template.root = new_root
        return applied_template

    def to_renderable(
        self, project_root: Path = Path("."), adjust_root: bool = True
    ) -> Renderable[Template]:
        applied_template = self.to_applied_template(
            project_root=project_root, adjust_root=adjust_root
        )
        renderable: Renderable[Template] = Renderable(
            template=self.template,
            data=applied_template.data,
            out_root=applied_template.root,
        )
        return renderable

    def matches_renderable(
        self,
        renderable: Renderable,
        project_root: Path = Path("."),
        render_root: Path = Path("."),
        adjust_root: bool = True,
    ) -> bool:
        """
        Note: Does not check template data
        """
        self_renderable = self.to_renderable(
            project_root=project_root, adjust_root=adjust_root
        )
        self_renderable_out_root: Path = self_renderable.out_root
        if not self_renderable_out_root.is_absolute():
            self_renderable_out_root = (
                render_root / self_renderable_out_root
            ).resolve()
        renderable_out_root: Path = renderable.out_root
        if not renderable_out_root.is_absolute():
            renderable_out_root = (render_root / renderable_out_root).resolve()
        return all(
            [
                self_renderable.template.name == renderable.template.name,
                self_renderable.template.version == renderable.template.version,
                self_renderable_out_root == renderable_out_root,
            ]
        )


def data_from_template_updates(updates: Sequence[TemplateUpdate]) -> List[TemplateData]:
    return [update.data or {} for update in updates]


def updates_with_updated_data(
    updates: Sequence[TemplateUpdate],
    data: Sequence[TemplateData],
    renderables: Sequence[Renderable],
    project_root: Path = Path("."),
    render_root: Path = Path("."),
    adjust_root: bool = True,
) -> List[TemplateUpdate]:
    if len(data) != len(renderables):
        raise InvalidTemplateDataException(
            f"should have equal length data {data} and renderables {renderables}"
        )
    out_updates: List[TemplateUpdate] = []
    for update in updates:
        new_update = deepcopy(update)
        # TODO: more efficient algorithm for matching rendered data with updates
        this_update_data: Optional[TemplateData] = None
        for i, renderable in enumerate(renderables):
            if update.matches_renderable(
                renderable,
                project_root=project_root,
                render_root=render_root,
                adjust_root=adjust_root,
            ):
                this_update_data = data[i]
                break
        if this_update_data is None:
            raise InvalidTemplateDataException(
                f"Could not find matching renderable for update {update} with "
                f"renderables {renderables}. Therefore data could not be matched"
            )
        new_update.data = this_update_data
        out_updates.append(new_update)
    return out_updates

        config: Optional[FlexlateConfig] = None,
    ) -> List[AppliedTemplateWithSource]:
        config = config or self.load_config(project_root)

        # TODO: more efficient algorithm for getting applied templates with sources

        def get_source_config_path(source_name: str) -> Path:
            if config is None:
                raise ValueError("should not hit this, for type narrowing")
            for child_config in config.child_configs:
                for source in child_config.template_sources:
                    if source.name == source_name:
                        return child_config.settings.config_location
            raise ValueError(f"could not find source {source_name}")

        sources = config.template_sources_dict
        applied_template_with_sources: List[AppliedTemplateWithSource] = []

        for child_config in config.child_configs:
            for i, applied_template in enumerate(child_config.applied_templates):
                source = sources[applied_template.name]
                source_config_path = get_source_config_path(source.name)
                applied_template_config_path = child_config.settings.config_location
                if (
                    relative_to is not None
                    and source.git_url is None
                    and not Path(source.path).is_absolute()
                ):
                    new_path = (relative_to / Path(source.path)).resolve()
                    use_source = source.copy(update=dict(path=new_path))
                else:
                    use_source = source
                applied_template_with_sources.append(
                    AppliedTemplateWithSource(
                        applied_template=applied_template,
                        source=use_source,
                        index=i,
                        source_config_path=source_config_path,
                        applied_template_config_path=applied_template_config_path,
                    )
                )
        return applied_template_with_sources

    def get_all_renderables(

    assert source.target_version == "some version"


# TODO: add AddMode.USER to tests by creating user config fixture


@patch.object(appdirs, "user_config_dir", lambda name: GENERATED_FILES_DIR)
@pytest.mark.parametrize("add_mode", [AddMode.LOCAL, AddMode.PROJECT])
def test_add_local_cookiecutter_applied_template_to_repo(
    add_mode: AddMode,
    repo_with_cookiecutter_one_template_source: Repo,
    cookiecutter_one_template: CookiecutterTemplate,
):