import collections

import errno

import shutil

import struct

import weakref

from .i18n import _

from .node import (

    bin,

    hex,

    nullrev,

)

from . import (

    error,

    filemerge,

    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'

CHANGE_ADDED = b'added'

CHANGE_REMOVED = b'removed'

CHANGE_MODIFIED = b'modified'

class MergeAction:

    """represent an "action" merge need to take for a given file

    Attributes:

    _short: internal representation used to identify each action

    no_op:  True if the action does affect the file content or tracking status

    narrow_safe:

        True if the action can be safely used for a file outside of the narrow

        set

    changes:

        The types of changes that this actions involves. This is a work in

        progress and not all actions have one yet. In addition, some requires

        user changes and cannot be fully decided. The value currently available

        are:

        - ADDED: the files is new in both parents

        - REMOVED: the files existed in one parent and is getting removed

        - MODIFIED: the files existed in at least one parent and is getting changed

    """

    ALL_ACTIONS = weakref.WeakSet()

    NO_OP_ACTIONS = weakref.WeakSet()

    def __init__(self, short, no_op=False, narrow_safe=False, changes=None):

        self._short = short

        self.ALL_ACTIONS.add(self)

        self.no_op = no_op

        if self.no_op:

            self.NO_OP_ACTIONS.add(self)

        self.narrow_safe = narrow_safe

        self.changes = changes

    def __hash__(self):

        return hash(self._short)

    def __repr__(self):

        return 'MergeAction<%s>' % self._short.decode('ascii')

    def __bytes__(self):

        return self._short

    def __eq__(self, other):

        if other is None:

            return False

        assert isinstance(other, MergeAction)

        return self._short == other._short

    def __lt__(self, other):

        return self._short < other._short

ACTION_FORGET = MergeAction(b'f', narrow_safe=True, changes=CHANGE_REMOVED)

ACTION_REMOVE = MergeAction(b'r', narrow_safe=True, changes=CHANGE_REMOVED)

ACTION_ADD = MergeAction(b'a', narrow_safe=True, changes=CHANGE_ADDED)

ACTION_GET = MergeAction(b'g', narrow_safe=True, changes=CHANGE_MODIFIED)

ACTION_PATH_CONFLICT = MergeAction(b'p')

ACTION_PATH_CONFLICT_RESOLVE = MergeAction('pr')

ACTION_ADD_MODIFIED = MergeAction(

    b'am', narrow_safe=True, changes=CHANGE_ADDED

)  # not 100% about the changes value here

ACTION_CREATED = MergeAction(b'c', narrow_safe=True, changes=CHANGE_ADDED)

ACTION_DELETED_CHANGED = MergeAction(b'dc')

ACTION_CHANGED_DELETED = MergeAction(b'cd')

ACTION_MERGE = MergeAction(b'm')

ACTION_LOCAL_DIR_RENAME_GET = MergeAction(b'dg')

ACTION_DIR_RENAME_MOVE_LOCAL = MergeAction(b'dm')

ACTION_KEEP = MergeAction(b'k', no_op=True)

# 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 = MergeAction(b'ka', no_op=True)

# 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 = MergeAction(b'kn', no_op=True)

ACTION_EXEC = MergeAction(b'e', narrow_safe=True, changes=CHANGE_MODIFIED)

ACTION_CREATED_MERGE = MergeAction(

    b'cm', narrow_safe=True, changes=CHANGE_ADDED

)

# Used by concert to detect situation it does not like, not sure what the exact

# criteria is

CONVERT_MERGE_ACTIONS = (

    ACTION_MERGE,

    ACTION_DIR_RENAME_MOVE_LOCAL,

    ACTION_CHANGED_DELETED,

    ACTION_DELETED_CHANGED,

)

class _mergestate_base:

    """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 self._state.items():

            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, dfile, wctx):

        """run merge process for dfile

        Returns the exit code of the merge."""

        if self[dfile] in (

            MERGE_RECORD_RESOLVED,

            LEGACY_RECORD_DRIVER_RESOLVED,

        ):

            return 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)