#! /usr/bin/env python3
"""Take some Git history and create a linear version of it.

Intended as a step in an automated cron job to update Git Fusion with a subset
of a huge Git repo.

Requires:
    - called with CWD = the giant repo.
    - local branch master points to history that you want to
      linearize then push.
    - remote "gf_origin" already set up with at least one successful push to
      its own "master" branch, with more than just 1 commit.
    - tag GF_LTP_LAST_LINEARIZED_BEFORE points to the last original
      Git commit that was later linearized via this script. This commit is the
      starting point for linearize_then_push.py's work load.
      linearize_then_push.py will advance this tag at the end of this script.
      GF_LTP_LAST_LINEARIZED_BEFORE must exist somewhere along master's
      --first-parent history: if not, call Perforce for help threading a linear
      path through some alternate history that's a lot harder to specify than
      the single word "--first-parent". And stop merging mainline into your dev
      branches. ^_^
    - tag GF_LTP_LAST_LINEARIZED_AFTER points to the Git commit that is
      a linearized counterpart to GF_LTP_LAST_LINEARIZED_BEFORE.
      This is the commit (and its preceding history) that we push
      through Git Fusion into Perforce.

Results:
    - Original history from GF_LTP_LAST_LINEARIZED_BEFORE..master converted
      to a linear version, no branches, no merges, just the --first-parent
      chain from master back to GF_LTP_LAST_LINEARIZED_BEFORE. This linearized
      history is connected previous value of GF_LTP_LAST_LINEARIZED_AFTER.
    - GF_LTP_LAST_LINEARIZED_BEFORE advanced to point to master.
    - GF_LTP_LAST_LINEARIZED_AFTER advanced to point to newly linearized
      history.
    - GF_LTP_LAST_LINEARIZED_AFTER pushed thorugh Git Fusion into Perforce
      remote gf_origin's branch master.
"""
import logging
import os
import pprint
import sys

import p4gf_env_config  # pylint:disable=unused-import
import p4gf_log
import p4gf_proc
import p4gf_util

                        # Log level reminder from p4gf_util.apply_log_args():
                        # verbose   = INFO
                        # <nothing> = WARNING
                        # quiet     = ERROR
                        #
                        # keep it as p4gf_rollback_stdout so it goes to stdout
LOG = logging.getLogger("p4gf_rollback_stdout")

# tag/branch names
GF_LTP_LAST_LINEARIZED_BEFORE        = "GF_LTP_LAST_LINEARIZED_BEFORE"
GF_LTP_LAST_LINEARIZED_AFTER         = "GF_LTP_LAST_LINEARIZED_AFTER"

                        # (optional) markers for each time you invoke
                        # this script.
                        #
                        # If you pass "--tag-num N" then this script will leave
                        # behind  tags in the before and after histories
                        # showing our original input 'master' and resulting
                        # pushed 'master'.
                        #
GF_LTP_UPDATE_N_BEFORE = "GF_LTP_UPDATE_{:>03s}_BEFORE"
GF_LTP_UPDATE_N_AFTER  = "GF_LTP_UPDATE_{:>03s}_AFTER"

GF_WORKING          = "GF_WORKING"

MASTER              = "master"
GF_ORIGIN           = "gf_origin"

                        # For less typing
_abbr = p4gf_util.abbrev
_gref = p4gf_util.git_rev_list_1


def main():
    """Do the thing."""
    p4gf_proc.init()
    args = _parse_argv()

    sha1_last_linearized_before = _gref(GF_LTP_LAST_LINEARIZED_BEFORE)
    sha1_last_linearized_after  = _gref(GF_LTP_LAST_LINEARIZED_AFTER)
    _report_begin()
    _require_preconditions( sha1_last_linearized_before
                          , sha1_last_linearized_after )

                    # Move our filter-branch ref to the end of
                    # history that we want to rewrite.
    _git_tag(GF_WORKING, MASTER)

                    # Linearize history.
                    # This can take a while.
    _linearize(
          orig_begin_ref         = GF_LTP_LAST_LINEARIZED_BEFORE
        , orig_end_ref           = GF_WORKING
        , orig_parent_sha1       = sha1_last_linearized_before
        , linearized_parent_sha1 = sha1_last_linearized_after
        )
                    # Advance our "last linearized" marker to
                    # the new location.
    _git_tag(GF_LTP_LAST_LINEARIZED_AFTER, GF_WORKING)
    _git_tag(GF_LTP_LAST_LINEARIZED_BEFORE, MASTER)
    if args.tag_num:
        tag_update_before = GF_LTP_UPDATE_N_BEFORE.format(str(args.tag_num))
        tag_update_after  = GF_LTP_UPDATE_N_AFTER.format(str(args.tag_num))
        _git_tag(tag_update_before, MASTER)
        _git_tag(tag_update_after, GF_WORKING)
    _git_tag(GF_WORKING, None)

    _report_end()

def _require_preconditions( sha1_last_linearized_before
                          , sha1_last_linearized_after ):
    """Raise exception if missing a required ref, or if master's
    --first-parent chain doesn't reach back to its previous value.
    """
    if not (sha1_last_linearized_before and sha1_last_linearized_after):
        raise RuntimeError("Missing required refs."
                  " Stopping before changing anything.")
    sha1_master = _gref(MASTER)
    if sha1_master == sha1_last_linearized_before:
        raise RuntimeError("Nothing to do: {} == {} == {}"
            .format(MASTER, GF_LTP_LAST_LINEARIZED_BEFORE, _abbr(sha1_master)))
    _require_reachable( GF_LTP_LAST_LINEARIZED_BEFORE
                      , sha1_last_linearized_before
                      , MASTER )


def _linearize( *
              , orig_begin_ref, orig_end_ref
              , orig_parent_sha1, linearized_parent_sha1 ):
    """ Run 'git filter-branch --parent-filter' on a subset of
    original history, linearizing it and connecting to linearized_parent_sha1.
    """
    script_py = _par_fil_abspath()
    cmd = [ "git", "filter-branch", "-f"
          , "--parent-filter"
          , '{script_py} {orig_parent_sha1} {linearized_parent_sha1}'
              .format(
                  script_py              = script_py
                , orig_parent_sha1       = orig_parent_sha1
                , linearized_parent_sha1 = linearized_parent_sha1)
          , "--"
          , "--first-parent"
          , "{orig_begin_ref}..{orig_end_ref}"
                .format(
                    orig_begin_ref  = orig_begin_ref
            ,       orig_end_ref    = orig_end_ref )
          ]
    LOG.info("Linearizing history {bn}/{bs}..{en}/{es} and connecting to"
             " previously linearized history at {lin_par} ..."
             .format( bn = orig_begin_ref
                    , bs = _abbr(_gref(orig_begin_ref))
                    , en = orig_end_ref
                    , es =_abbr(_gref(orig_end_ref))
                    , lin_par = _abbr(linearized_parent_sha1)
                    ))
    _run(cmd)


def _run(cmd):
    """Log a shell command."""
    LOG.debug(' '.join(cmd))
    r = p4gf_proc.popen(cmd)
    # pylint:disable=maybe-no-member
    LOG.debug2(pprint.pformat(r))
    return r


def _par_fil_abspath():
    """Return the absolute path to our --parent-filter script."""
    bin_dir = os.path.dirname(sys.argv[0])
    script_abspath = os.path.join(bin_dir, "linearizing_parent_filter.py")
    return script_abspath


def _git_tag(tag_name, tag_points_to):
    """ git tag -f MYTAG some_sha1 """
    if tag_points_to:
        cmd = ["git", "tag", "-f", tag_name, tag_points_to ]
    else:
        cmd = ["git", "tag", "-d", tag_name ]
    _run(cmd)


def _require_reachable( require_name, require_sha1
                      , reachable_from_ref_name):
    """Require that the given sha1 exists somewhere in ref_name's
    --first-parent history. If not, raise a runtime error.
    """
    reachable_from_sha1 = _abbr(_gref(reachable_from_ref_name))
    cmd = ["git", "rev-list", "--first-parent", reachable_from_ref_name]
    d = _run(cmd)
    for line in d['out'].splitlines():
        if require_sha1 in line:
            LOG.debug("Found {rn}/{rs} in --first-parent history of {fn}/{fs}"
                      .format( rn = require_name
                             , rs = _abbr(require_sha1)
                             , fn = reachable_from_ref_name
                             , fs = reachable_from_sha1
                             ))
            return True
    raise RuntimeError(
"""Previous {rn}/{rs} not found in --first-parent history of {fn}/{fs}.
Someone needs to write a 'git filter-branch --parent-filter' script
that can carve a linear path between old {rn} and current {fn}.
"""
          .format( rn = require_name
                 , rs = _abbr(require_sha1)
                 , fn = reachable_from_ref_name
                 , fs = reachable_from_sha1
                 ))


def _report_begin():
    """Dump the world before we change anything."""
    LOG.info("Starting ref locations:")
    refs = [ MASTER
           , GF_LTP_LAST_LINEARIZED_BEFORE
           , GF_LTP_LAST_LINEARIZED_AFTER
           ]
    _report_refs(refs)


def _report_end():
    """Dump the world before we change anything."""
    LOG.info("Ending ref locations:")
    refs = [ GF_LTP_LAST_LINEARIZED_BEFORE
           , GF_LTP_LAST_LINEARIZED_AFTER ]
    _report_refs(refs)


def _report_refs(ref_list):
    """Dump a bunch of "ref : sha1" lines to LOG.info."""
    for ref in ref_list:
        sha1 = _gref(ref)
        LOG.info("{:<40} {}".format(ref, _abbr(sha1)))


def _parse_argv():
    """Convert command line into a usable dict."""
    parser = p4gf_util.create_arg_parser(
          add_log_args  = True
        , add_debug_arg = True
        )
    parser.add_argument('--tag-num', default=0)
    args = parser.parse_args()
    p4gf_util.apply_log_args(args, LOG)
    LOG.debug("args={}".format(args))
    args.tag_num = int(args.tag_num)
    return args


if __name__ == "__main__":
    p4gf_log.run_with_exception_logger(main, write_to_stderr=True)