from __future__ import absolute_import

import errno

import shutil

import struct

from .i18n import _

from .node import (

    bin,

    hex,

    nullhex,

    nullid,

)

from .pycompat import delattr

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'

# store info about merge driver used and it's state

RECORD_MERGE_DRIVER_STATE = b'm'

#####

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

RECORD_MERGE_DRIVER_MERGE = b'D'

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

MERGE_RECORD_DRIVER_RESOLVED = b'd'

# represents that the file was automatically merged in favor

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

MERGE_RECORD_MERGED_OTHER = b'o'

#####

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

# exists

#####

RECORD_OVERRIDE = b't'

#####

# possible states which a merge driver can have. These are stored inside a

# RECORD_MERGE_DRIVER_STATE entry

#####

MERGE_DRIVER_STATE_UNMARKED = b'u'

MERGE_DRIVER_STATE_MARKED = b'm'

MERGE_DRIVER_STATE_SUCCESS = b's'

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'

ACTION_EXEC = b'e'

ACTION_CREATED_MERGE = b'cm'

# GET the other/remote side and store this info in mergestate

ACTION_GET_OTHER_AND_STORE = b'gs'

class mergestate(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

    D: a file that the external merge driver will merge internally

       (experimental)

    P: a path conflict (file vs directory)

    m: the external merge driver defined for this merge plus its run state

       (experimental)

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

    l: the labels for the parts of the merge.

    Merge driver run states (experimental):

    u: driver-resolved files unmarked -- needs to be run next time we're about

       to resolve or commit

    m: driver-resolved files marked -- only needs to be run before commit

    s: success/skipped -- does not need to be run any more

    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

    d: driver-resolved conflict

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

    'pu' and 'pr' for path conflicts.

    '''

    statepathv1 = b'merge/state'

    statepathv2 = b'merge/state2'

    @staticmethod

    def clean(repo, node=None, other=None, labels=None):

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

        disk."""

        ms = mergestate(repo)

        ms.reset(node, other, labels)

        return ms

    @staticmethod

    def read(repo):

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

        ms = mergestate(repo)

        ms._read()

        return ms

    def __init__(self, repo):

        """Initialize the merge state.

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

        self._repo = repo

        self._dirty = False

        self._labels = None

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

        self._state = {}

        self._stateextras = {}

        self._local = None

        self._other = None

        self._labels = labels

        for var in ('localctx', 'otherctx'):

            if var in vars(self):

                delattr(self, var)

        if node:

            self._local = node

            self._other = other

        self._readmergedriver = None

        if self.mergedriver:

            self._mdstate = MERGE_DRIVER_STATE_SUCCESS

        else:

            self._mdstate = MERGE_DRIVER_STATE_UNMARKED

        shutil.rmtree(self._repo.vfs.join(b'merge'), True)

        self._results = {}

        self._dirty = False

    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.

        """

        self._state = {}

        self._stateextras = {}

        self._local = None

        self._other = None

        for var in ('localctx', 'otherctx'):

            if var in vars(self):

                delattr(self, var)

        self._readmergedriver = None

        self._mdstate = MERGE_DRIVER_STATE_SUCCESS

        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 == RECORD_MERGE_DRIVER_STATE:

                bits = record.split(b'\0', 1)

                mdstate = bits[1]

                if len(mdstate) != 1 or mdstate not in (

                    MERGE_DRIVER_STATE_UNMARKED,

                    MERGE_DRIVER_STATE_MARKED,

                    MERGE_DRIVER_STATE_SUCCESS,

                ):

                    # the merge driver should be idempotent, so just rerun it

                    mdstate = MERGE_DRIVER_STATE_UNMARKED

                self._readmergedriver = bits[0]

                self._mdstate = mdstate

            elif rtype in (

                RECORD_MERGED,

                RECORD_CHANGEDELETE_CONFLICT,

                RECORD_PATH_CONFLICT,

                RECORD_MERGE_DRIVER_MERGE,

            ):

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

                self._state[bits[0]] = bits[1:]

            elif rtype == RECORD_FILE_VALUES:

                filename, rawextras = record.split(b'\0', 1)

                extraparts = rawextras.split(b'\0')

                extras = {}

                i = 0

                while i < len(extraparts):

                    extras[extraparts[i]] = extraparts[i + 1]

                    i += 2

                self._stateextras[filename] = extras

            elif rtype == RECORD_LABELS:

                labels = record.split(b'\0', 2)

                self._labels = [l for l in labels if len(l) > 0]

            elif not rtype.islower():

                unsupported.add(rtype)

        self._results = {}

        self._dirty = False

        if unsupported:

            raise error.UnsupportedMergeRecords(unsupported)

    def _readrecords(self):

        """Read merge state from disk and return a list of record (TYPE, data)

        We read data from both v1 and v2 files and decide which one to use.

        V1 has been used by version prior to 2.9.1 and contains less data than

        v2. We read both versions and check if no data in v2 contradicts

        v1. If there is not contradiction we can safely assume that both v1

        and v2 were written at the same time and use the extract data in v2. If

        there is contradiction we ignore v2 content as we assume an old version

        of Mercurial has overwritten the mergestate file and left an old v2

        file around.

        returns list of record [(TYPE, data), ...]"""

        v1records = self._readrecordsv1()

        v2records = self._readrecordsv2()

        if self._v1v2match(v1records, v2records):

            return v2records

        else:

            # v1 file is newer than v2 file, use it

            # we have to infer the "other" changeset of the merge

            # we cannot do better than that with v1 of the format

            mctx = self._repo[None].parents()[-1]

            v1records.append((RECORD_OTHER, mctx.hex()))

            # add place holder "other" file node information

            # nobody is using it yet so we do no need to fetch the data

            # if mctx was wrong `mctx[bits[-2]]` may fails.

            for idx, r in enumerate(v1records):

                if r[0] == RECORD_MERGED:

                    bits = r[1].split(b'\0')

                    bits.insert(-2, b'')

                    v1records[idx] = (r[0], b'\0'.join(bits))

            return v1records

    def _v1v2match(self, v1records, v2records):

        oldv2 = set()  # old format version of v2 record

        for rec in v2records:

            if rec[0] == RECORD_LOCAL:

                oldv2.add(rec)

            elif rec[0] == RECORD_MERGED:

                # drop the onode data (not contained in v1)

                oldv2.add((RECORD_MERGED, _droponode(rec[1])))

        for rec in v1records:

            if rec not in oldv2:

                return False

        else:

            return True

    def _readrecordsv1(self):

        """read on disk merge state for version 1 file

        returns list of record [(TYPE, data), ...]

        Note: the "F" data from this file are one entry short

              (no "other file node" entry)

        """

        records = []

        try:

            f = self._repo.vfs(self.statepathv1)

            for i, l in enumerate(f):

                if i == 0:

                    records.append((RECORD_LOCAL, l[:-1]))

                else:

                    records.append((RECORD_MERGED, l[:-1]))

            f.close()

        except IOError as err:

            if err.errno != errno.ENOENT:

                raise

        return records

    def _readrecordsv2(self):

        """read on disk merge state for version 2 file

        This format is a list of arbitrary records of the form:

          [type][length][content]

        `type` is a single character, `length` is a 4 byte integer, and

        `content` is an arbitrary byte sequence of length `length`.

        Mercurial versions prior to 3.7 have a bug where if there are

        unsupported mandatory merge records, attempting to clear out the merge

        state with hg update --clean or similar aborts. The 't' record type

        works around that by writing out what those versions treat as an

        advisory record, but later versions interpret as special: the first

        character is the 'real' record type and everything onwards is the data.

        Returns list of records [(TYPE, data), ...]."""

        records = []

        try:

            f = self._repo.vfs(self.statepathv2)

            data = f.read()

            off = 0

            end = len(data)

            while off < end:

                rtype = data[off : off + 1]

                off += 1

                length = _unpack(b'>I', data[off : (off + 4)])[0]

                off += 4

                record = data[off : (off + length)]

                off += length

                if rtype == RECORD_OVERRIDE:

                    rtype, record = record[0:1], record[1:]

                records.append((rtype, record))

            f.close()

        except IOError as err:

            if err.errno != errno.ENOENT:

                raise

        return records

    @util.propertycache

    def mergedriver(self):

        # protect against the following:

        # - A configures a malicious merge driver in their hgrc, then

        #   pauses the merge

        # - A edits their hgrc to remove references to the merge driver

        # - A gives a copy of their entire repo, including .hg, to B

        # - B inspects .hgrc and finds it to be clean

        # - B then continues the merge and the malicious merge driver

        #  gets invoked

        configmergedriver = self._repo.ui.config(

            b'experimental', b'mergedriver'

        )