from __future__ import absolute_import

import collections

import errno

import shutil

import struct

from .i18n import _

from .node import (

    bin,

    hex,

    nullhex,

    nullid,

)

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 == 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'

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'

ACTION_EXEC = b'e'

ACTION_CREATED_MERGE = b'cm'

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

    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 = 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 extras(self, 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().

        """

            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.node() == nullid 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 != 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._stateextras.pop(dfile, None)

            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

                elif fco.isabsent():  # cd: local picked

                    if dfile in self.localctx:

                        action = ACTION_ADD_MODIFIED

                    else:

                        action = ACTION_ADD

                # else: regular merges (no action necessary)

            self._results[dfile] = merge_ret, action

        return complete, merge_ret

    def preresolve(self, dfile, wctx):

        """run premerge process for dfile

        Returns whether the merge is complete, and the exit code."""

        return self._resolve(True, dfile, wctx)

    def resolve(self, dfile, wctx):

        """run merge process (assuming premerge was run) for dfile

        Returns the exit code of the merge."""

        return self._resolve(False, dfile, wctx)[1]

    def counts(self):

        """return counts for updated, merged and removed files in this

        session"""

        updated, merged, removed = 0, 0, 0

        for r, action in pycompat.itervalues(self._results):

            if r is None:

                updated += 1

            elif r == 0:

                if action == ACTION_REMOVE:

                    removed += 1

                else:

                    merged += 1

        return updated, merged, removed

    def unresolvedcount(self):

        """get unresolved count for this merge (persistent)"""

        return len(list(self.unresolved()))

    def actions(self):

        """return lists of actions to perform on the dirstate"""

        actions = {

            ACTION_REMOVE: [],

            ACTION_FORGET: [],

            ACTION_ADD: [],

            ACTION_ADD_MODIFIED: [],

            ACTION_GET: [],

        }

        for f, (r, action) in pycompat.iteritems(self._results):

            if action is not None:

                actions[action].append((f, None, b"merge result"))

        return actions

class mergestate(_mergestate_base):

    statepathv1 = b'merge/state'

    statepathv2 = b'merge/state2'

    @staticmethod

    def clean(repo):

        """Initialize a brand new merge state, removing any existing state on

        disk."""

        ms = mergestate(repo)

        ms.reset()

        return ms

    @staticmethod

    def read(repo):

        """Initialize the merge state, reading it from disk."""

        ms = mergestate(repo)

        ms._read()

        return ms

    def _read(self):

        """Analyse each record content to restore a serialized state from disk

        This function process "record" entry produced by the de-serialization

        of on disk file.

        """

        unsupported = set()

        records = self._readrecords()

        for rtype, record in records:

            if rtype == RECORD_LOCAL:

                self._local = bin(record)

            elif rtype == RECORD_OTHER:

                self._other = bin(record)

            elif rtype in (

                RECORD_MERGED,

                RECORD_CHANGEDELETE_CONFLICT,

                RECORD_PATH_CONFLICT,