#! /usr/bin/env python3.3
"""Information about a column in G2PMatrix.

Moved to a separate file solely to make it easier to edit without a
lot of scrolling.
"""
import p4gf_branch
import p4gf_depot_branch
from   p4gf_l10n    import NTR
import p4gf_util


class G2PMatrixColumn:

    """A source of change that contributes to a Git commit."""

            # Values for col_type

            # Git destination intersection with current Perforce branch view.
            #
            # Receives this Git commit.
            # .change_num set to previous changelist (if any) on this
            # Perforce branch.
            #
            # cell.discovered:
            #   git-action : from git-fast-export
            #   mode       : from git-ls-tree
            #                Currently ALL modes recorded, might thin down
            #                to just symlink=120000 if that's all we need.
            #   p4 files //client/...@n
            #
    GDEST = 'GDEST'

            # One Git parent commit, intersected with one Perforce branch view.
            #
            # Each Git parent may intersect multiple Peforce branches, but we
            # retain only the most recent (highest changelist number) column
            # for any single branch, so a single Branch appears no more than
            # once in our GPARN list.
            #
            # cell.discovered:
            #                   If populating first changelist on new branch:
            #   p4 copy -n -b <tmp> //...@n
            #   p4 files //client/...@n
            #
            #                   Always
            #   p4 integ -n -t -d -i -b <tmp> //...@n
            #   p4 files //client/...@n
            #
    GPARN = 'GPARN'

            # One Git parent commit, intersected with one Perforce branch view,
            # if a counterpart GPARN column is lightweight and has a
            # fully-populated basis. This is that basis.
            #
            # (Some lightweight GPARN branches lack a fully populated basis,
            #  so don't expect one GPARFPN for each lightweight GPARN.)
            #
            # Often this is identical to P4JITFP, since a lightweight branch
            # uses the same fully populated basis as its first parent.
            #
            # cell.discovered:
            #                   If populating first changelist on new FP branch:
            #   p4 copy -n -b <tmp> //...@n
            #   p4 files //client/...@n
            #
    GPARFPN = 'GPARFPN'

            # Fully populated basis for Just-in-Time branch actions.
            #
            # If destination branch is lightweight, then this column tells from
            # where to integ files that have not yet been populated into the
            # destination branch.
            #
            # Discovery is what files COULD be JIT-branched if necessary.
            #
            # cell.discovered:
            #   p4 files //client/...@n
            #
    P4JITFP = 'P4JITFP'

            # Implied parent on same Perforce branch.
            #
            # If the previous Perforce changelist on GDEST's Perforce branch
            # does not correspond to any Git parent GPARN, then list that
            # previous Perforce changelist here as an implicit parent.
            # Any integ action here is invoked ONLY if there are no other
            # integ actions AND we decide to add/edit/delete.
            #
            # cell.discovered:
            #   git-action : git-diff-tree p4imply's-commit.sha1
            #                gdest's-commit.sha1
            #   mode       : git-ls-tree
            #
    P4IMPLY = 'P4IMPLY'


            # A Perforce changelist we create and submit in order to stage
            # GDEST's depot branch to receive the pending Git commit.
            #
            # Also contains integ (branch) actions to perform the first half of
            # JIT-branch-for-delete, and integ (branch) actions to populate the
            # first commit of a new depot branch.
            #
            # Column header data is same as Git Nth-parent column, if one
            # exists, or empty/None if the current Git commit is a root/orphan
            # with no parent commit.
            #
            # cell.discovered
            #   git-action : git-diff-tree to convert p4imply's state
            #                to GPARN first-parent's state.
            #
            #   git-mode   : file mode and sha1 of file in GPARN, aka
            #   sha1       : ...the commit this GHOST is attempting to
            #                ...recreate
            #
    GHOST   = 'GHOST'

            # A short reminder of what appears in which p4 result dict:
            #
            # p4 files:
            #   ... depotFile //depot/main/about-this-folder.txt
            #   ... rev 2
            #   ... change 566664
            #   ... action delete
            #   ... type text
            #   ... time 1355530980
            #
            # p4 integ -n -t -i -d -b <tmp> //...@n
            # p4 copy  -n          -b <tmp> //...@n
            #   ... depotFile //depot/main/about-this-folder.txt
            #   ... clientFile /Users/zig/p4/depot/main/about-this-folder.txt
            #   ... workRev 1
            #   ... action branch
            #   ... ... otherAction sync
            #   ... fromFile //depot/dev/git-fusion/bin/about-this-folder.txt
            #   ... startFromRev none
            #   ... endFromRev 2

    def __init__( self
                , col_type          = None
                , branch            = None
                , depot_branch      = None
                , sha1              = None
                , change_num        = 0
                , is_first_parent   = False
                , fp_counterpart    = None
                ):
    # pylint:disable=too-many-arguments
    # This is intentional. I prefer to fully construct an instance with a
    # single call to an initializer, not construct, then assign, assign, assign.
        assert isinstance(change_num, int)

        self.col_type   = col_type

                    # If fully populated basis GPARFPN or P4JITFP, then branch
                    # is the lightweight branch for which we serve as a basis,
                    # not the fully populated branch (which is often None).
        self.branch         = branch

                    # Where this lightweight branch's files live.
                    # None if this is a fully populated branch, or if this is
                    # the GPARFPN fully populated basis for some other
                    # lightweight GPARN branch.
        self.depot_branch   = depot_branch

        self.sha1           = sha1
        self.change_num     = change_num

                    # +++ index within G2PMatrix.columns, lets us more quickly
                    #     index into G2PMatrixRow.cells[] or
                    #     G2PMatrix.columns[].
                    #     Set at end of G2PMatrix._discover_branches() when we
                    #     fill in G2PMatrix.columns[].
        self.index          = -1

                    # Is this a GPARN column that corresponds to Git's
                    # first-parent commit?
        self.is_first_parent    = is_first_parent

                    # Latches True in G2PMatrix._files_at()
        self.discovered_p4files = False

                    # Latches True in G2PMatrix._fstat_at()
        self.discovered_p4fstat = False

                    # If we are a GPARN column, what is our FP basis (if any?)
                    # If we are a GPARFPN column, what lightweight GPARN uses
                    # us as a basis? (We never share a single GPARFPN across
                    # multiple GPARNs)
        self.fp_counterpart     = fp_counterpart
        if fp_counterpart:
            fp_counterpart.fp_counterpart = self

    def to_log_level(self, _level):
        """Debugging dump."""
        # Single-line dump
        fmt = (NTR('{index}: {col_type:<7} b={branch:<7} d={dbi:<7}'
                   ' {sha1:<7} ch={ch:>4} {first_parent:<9} {fp_counterpart}'))
        fp_counterpart = (NTR(' fp_counter=[{i}]')
                          .format(i=self.fp_counterpart.index)
                          if self.fp_counterpart else '')
        return fmt.format(
                  index          = self.index
                , col_type       = self.col_type
                , branch         = p4gf_branch.abbrev(self.branch)
                , dbi            = p4gf_depot_branch.abbrev(self.depot_branch)
                , sha1           = p4gf_util.abbrev(self.sha1)
                , ch             = self.change_num
                , first_parent   = 'first-par' if self.is_first_parent else ''
                , fp_counterpart = fp_counterpart
                )

    @staticmethod
    def count(lst, col_type):
        """How many GPARN columns do we have?"""
        ct = 0
        for c in lst:
            if c.col_type == col_type:
                ct += 1
        return ct

    @staticmethod
    def find(lst, col_type):
        """Seek."""
        for c in lst:
            if c.col_type == col_type:
                return c
        return None

    @staticmethod
    def find_fp_basis(lst, gparn):
        """If gparn is lightweight, it (usually) has a corresponding GPARFPN
        column somewhere. Return that. Return None if no FP basis.

        DO NOT USE WITH MATRIX 2
        Matrix 2 stores GPARFPN's actual sha1, not a copy of GPARN's sha1.
        """
        if not gparn.branch.is_lightweight:
            return None
        for c in lst:
            if (    (c.col_type == G2PMatrixColumn.GPARFPN)
                and (c.branch   == gparn.branch)
                and (c.sha1     == gparn.sha1)):
                return c
        return None

    @staticmethod
    def of_col_type(lst, col_type):
        """Subset of lst with matching col_type. Stable ordering."""
        return [c for c in lst if c.col_type == col_type]

    @staticmethod
    def find_first_parent(lst):
        """Return a GPARN column that corresponds to our Git first-parent."""
                      # Prefer fully populated columns when available.
                      # Save first lightweight hit to use if we
                      # don't find something better.
        hit = None
        for col in lst:
            if (    col.is_first_parent
                and col.col_type == G2PMatrixColumn.GPARN):
                if not col.branch.is_lightweight:
                    return col
                if not hit:
                    hit = col
        return hit