from __future__ import absolute_import

import collections

import errno

import shutil

import struct

from .i18n import _

from .node import (

    bin,

    hex,

    nullrev,

)

from . import (

    error,

    filemerge,

    pycompat,

    util,

)

from .utils import hashutil

_pack = struct.pack

_unpack = struct.unpack

def _droponode(data):

    # used for compatibility for v1

    bits = data.split(b'\0')

    bits = bits[:-2] + bits[-1:]

    return b'\0'.join(bits)

def _filectxorabsent(hexnode, ctx, f):

    if hexnode == ctx.repo().nodeconstants.nullhex:

        return filemerge.absentfilectx(ctx, f)

    else:

        return ctx[f]

# Merge state record types. See ``mergestate`` docs for more.

####

# merge records which records metadata about a current merge

# exists only once in a mergestate

#####

RECORD_LOCAL = b'L'

RECORD_OTHER = b'O'

# record merge labels

RECORD_LABELS = b'l'

#####

# record extra information about files, with one entry containing info about one

# file. Hence, multiple of them can exists

#####

RECORD_FILE_VALUES = b'f'

#####

# merge records which represents state of individual merges of files/folders

# These are top level records for each entry containing merge related info.

# Each record of these has info about one file. Hence multiple of them can

# exists

#####

RECORD_MERGED = b'F'

RECORD_CHANGEDELETE_CONFLICT = b'C'

# the path was dir on one side of merge and file on another

RECORD_PATH_CONFLICT = b'P'

#####

# possible state which a merge entry can have. These are stored inside top-level

# merge records mentioned just above.

#####

MERGE_RECORD_UNRESOLVED = b'u'

MERGE_RECORD_RESOLVED = b'r'

MERGE_RECORD_UNRESOLVED_PATH = b'pu'

MERGE_RECORD_RESOLVED_PATH = b'pr'

# represents that the file was automatically merged in favor

# of other version. This info is used on commit.

# This is now deprecated and commit related information is now

# stored in RECORD_FILE_VALUES

MERGE_RECORD_MERGED_OTHER = b'o'

#####

# top level record which stores other unknown records. Multiple of these can

# exists

#####

RECORD_OVERRIDE = b't'

#####

# legacy records which are no longer used but kept to prevent breaking BC

#####

# This record was release in 5.4 and usage was removed in 5.5

LEGACY_RECORD_RESOLVED_OTHER = b'R'

# This record was release in 3.7 and usage was removed in 5.6

LEGACY_RECORD_DRIVER_RESOLVED = b'd'

# This record was release in 3.7 and usage was removed in 5.6

LEGACY_MERGE_DRIVER_STATE = b'm'

# This record was release in 3.7 and usage was removed in 5.6

LEGACY_MERGE_DRIVER_MERGE = b'D'

ACTION_FORGET = b'f'

ACTION_REMOVE = b'r'

ACTION_ADD = b'a'

ACTION_GET = b'g'

ACTION_PATH_CONFLICT = b'p'

ACTION_PATH_CONFLICT_RESOLVE = b'pr'

ACTION_ADD_MODIFIED = b'am'

ACTION_CREATED = b'c'

ACTION_DELETED_CHANGED = b'dc'

ACTION_CHANGED_DELETED = b'cd'

ACTION_MERGE = b'm'

ACTION_LOCAL_DIR_RENAME_GET = b'dg'

ACTION_DIR_RENAME_MOVE_LOCAL = b'dm'

ACTION_KEEP = b'k'

# the file was absent on local side before merge and we should

# keep it absent (absent means file not present, it can be a result

# of file deletion, rename etc.)

ACTION_KEEP_ABSENT = b'ka'

# the file is absent on the ancestor and remote side of the merge

# hence this file is new and we should keep it

ACTION_KEEP_NEW = b'kn'

ACTION_EXEC = b'e'

ACTION_CREATED_MERGE = b'cm'

# actions which are no op

NO_OP_ACTIONS = (

    ACTION_KEEP,

    ACTION_KEEP_ABSENT,

    ACTION_KEEP_NEW,

)

class _mergestate_base(object):

    """track 3-way merge state of individual files

    The merge state is stored on disk when needed. Two files are used: one with

    an old format (version 1), and one with a new format (version 2). Version 2

    stores a superset of the data in version 1, including new kinds of records

    in the future. For more about the new format, see the documentation for

    `_readrecordsv2`.

    Each record can contain arbitrary content, and has an associated type. This

    `type` should be a letter. If `type` is uppercase, the record is mandatory:

    versions of Mercurial that don't support it should abort. If `type` is

    lowercase, the record can be safely ignored.

    Currently known records:

    L: the node of the "local" part of the merge (hexified version)

    O: the node of the "other" part of the merge (hexified version)

    F: a file to be merged entry

    C: a change/delete or delete/change conflict

    P: a path conflict (file vs directory)

    f: a (filename, dictionary) tuple of optional values for a given file

    l: the labels for the parts of the merge.

    Merge record states (stored in self._state, indexed by filename):

    u: unresolved conflict

    r: resolved conflict

    pu: unresolved path conflict (file conflicts with directory)

    pr: resolved path conflict

    o: file was merged in favor of other parent of merge (DEPRECATED)

    The resolve command transitions between 'u' and 'r' for conflicts and

    'pu' and 'pr' for path conflicts.

    """

    def __init__(self, repo):

        """Initialize the merge state.

        Do not use this directly! Instead call read() or clean()."""

        self._repo = repo

        self._state = {}

        self._stateextras = collections.defaultdict(dict)

        self._local = None

        self._other = None

        self._labels = None

        # contains a mapping of form:

        # {filename : (merge_return_value, action_to_be_performed}

        # these are results of re-running merge process

        # this dict is used to perform actions on dirstate caused by re-running

        # the merge

        self._results = {}

        self._dirty = False

    def reset(self):

        pass

    def start(self, node, other, labels=None):

        self._local = node

        self._other = other

        self._labels = labels

    @util.propertycache

    def local(self):

        if self._local is None:

            msg = b"local accessed but self._local isn't set"

            raise error.ProgrammingError(msg)

        return self._local

    @util.propertycache

    def localctx(self):

        return self._repo[self.local]

    @util.propertycache

    def other(self):

        if self._other is None:

            msg = b"other accessed but self._other isn't set"

            raise error.ProgrammingError(msg)

        return self._other

    @util.propertycache

    def otherctx(self):

        return self._repo[self.other]

    def active(self):

        """Whether mergestate is active.

        Returns True if there appears to be mergestate. This is a rough proxy

        for "is a merge in progress."

        """

        return bool(self._local) or bool(self._state)

    def commit(self):

        """Write current state on disk (if necessary)"""

    @staticmethod

    def getlocalkey(path):

        """hash the path of a local file context for storage in the .hg/merge

        directory."""

        return hex(hashutil.sha1(path).digest())

    def _make_backup(self, fctx, localkey):

        raise NotImplementedError()

    def _restore_backup(self, fctx, localkey, flags):

        raise NotImplementedError()

    def add(self, fcl, fco, fca, fd):

        """add a new (potentially?) conflicting file the merge state

        fcl: file context for local,

        fco: file context for remote,

        fca: file context for ancestors,

        fd:  file path of the resulting merge.

        note: also write the local version to the `.hg/merge` directory.

        """

        if fcl.isabsent():

            localkey = self._repo.nodeconstants.nullhex

        else:

            localkey = mergestate.getlocalkey(fcl.path())

            self._make_backup(fcl, localkey)

        self._state[fd] = [

            MERGE_RECORD_UNRESOLVED,

            localkey,

            fcl.path(),

            fca.path(),

            hex(fca.filenode()),

            fco.path(),

            hex(fco.filenode()),

            fcl.flags(),

        ]

        self._stateextras[fd][b'ancestorlinknode'] = hex(fca.node())

        self._dirty = True

    def addpathconflict(self, path, frename, forigin):

        """add a new conflicting path to the merge state

        path:    the path that conflicts

        frename: the filename the conflicting file was renamed to

        forigin: origin of the file ('l' or 'r' for local/remote)

        """

        self._state[path] = [MERGE_RECORD_UNRESOLVED_PATH, frename, forigin]

        self._dirty = True

    def addcommitinfo(self, path, data):

        """stores information which is required at commit

        into _stateextras"""

        self._stateextras[path].update(data)

        self._dirty = True

    def __contains__(self, dfile):

        return dfile in self._state

    def __getitem__(self, dfile):

        return self._state[dfile][0]

    def __iter__(self):

        return iter(sorted(self._state))

    def files(self):

        return self._state.keys()

    def mark(self, dfile, state):

        self._state[dfile][0] = state

        self._dirty = True

    def unresolved(self):

        """Obtain the paths of unresolved files."""

        for f, entry in pycompat.iteritems(self._state):

            if entry[0] in (

                MERGE_RECORD_UNRESOLVED,

                MERGE_RECORD_UNRESOLVED_PATH,

            ):

                yield f

    def allextras(self):

        """ return all extras information stored with the mergestate """

        return self._stateextras

    def extras(self, filename):

        """ return extras stored with the mergestate for the given filename """

        return self._stateextras[filename]

    def _resolve(self, preresolve, dfile, wctx):

        """rerun merge process for file path `dfile`.

        Returns whether the merge was completed and the return value of merge

        obtained from filemerge._filemerge().

        """

        if self[dfile] in (

            MERGE_RECORD_RESOLVED,

            LEGACY_RECORD_DRIVER_RESOLVED,

        ):

            return True, 0

        stateentry = self._state[dfile]

        state, localkey, lfile, afile, anode, ofile, onode, flags = stateentry

        octx = self._repo[self._other]

        extras = self.extras(dfile)

        anccommitnode = extras.get(b'ancestorlinknode')

        if anccommitnode:

            actx = self._repo[anccommitnode]

        else:

            actx = None

        fcd = _filectxorabsent(localkey, wctx, dfile)

        fco = _filectxorabsent(onode, octx, ofile)

        # TODO: move this to filectxorabsent

        fca = self._repo.filectx(afile, fileid=anode, changectx=actx)

        # "premerge" x flags

        flo = fco.flags()

        fla = fca.flags()

        if b'x' in flags + flo + fla and b'l' not in flags + flo + fla:

            if fca.rev() == nullrev and flags != flo:

                if preresolve:

                    self._repo.ui.warn(

                        _(

                            b'warning: cannot merge flags for %s '

                            b'without common ancestor - keeping local flags\n'

                        )

                        % afile

                    )

            elif flags == fla:

                flags = flo

        if preresolve:

            # restore local

            if localkey != self._repo.nodeconstants.nullhex:

                self._restore_backup(wctx[dfile], localkey, flags)

            else:

                wctx[dfile].remove(ignoremissing=True)

            complete, merge_ret, deleted = filemerge.premerge(

                self._repo,

                wctx,

                self._local,

                lfile,

                fcd,

                fco,

                fca,

                labels=self._labels,

            )

        else:

            complete, merge_ret, deleted = filemerge.filemerge(

                self._repo,

                wctx,

                self._local,

                lfile,

                fcd,

                fco,

                fca,

                labels=self._labels,

            )

        if merge_ret is None:

            # If return value of merge is None, then there are no real conflict

            del self._state[dfile]

            self._dirty = True

        elif not merge_ret:

            self.mark(dfile, MERGE_RECORD_RESOLVED)

        if complete:

            action = None

            if deleted:

                if fcd.isabsent():

                    # dc: local picked. Need to drop if present, which may

                    # happen on re-resolves.

                    action = ACTION_FORGET

                else:

                    # cd: remote picked (or otherwise deleted)

                    action = ACTION_REMOVE

            else:

                if fcd.isabsent():  # dc: remote picked

                    action = ACTION_GET