# merge.py - directory-level update/merge handling for Mercurial

#

# Copyright 2006, 2007 Matt Mackall <mpm@selenic.com>

#

# This software may be used and distributed according to the terms of the

# GNU General Public License version 2 or any later version.

from __future__ import absolute_import

import errno

import os

import shutil

import struct

from .i18n import _

from .node import (

    bin,

    hex,

    nullid,

    nullrev,

)

from . import (

    copies,

    error as errormod,

    filemerge,

    obsolete,

    subrepo,

    util,

    worker,

)

_pack = struct.pack

_unpack = struct.unpack

def _droponode(data):

    # used for compatibility for v1

    bits = data.split('\0')

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

    return '\0'.join(bits)

class mergestate(object):

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

    it is stored on disk when needed. Two file are used, one with an old

    format, one with a new format. Both contains similar data, but the new

    format can store new kind of field.

    Current new format is a list of arbitrary record of the form:

        [type][length][content]

    Type is a single character, length is a 4 bytes integer, content is an

    arbitrary suites of bytes of length `length`.

    Type should be a letter. Capital letter are mandatory record, Mercurial

    should abort if they are unknown. lower case record can be safely ignored.

    Currently known record:

    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

    '''

    statepathv1 = 'merge/state'

    statepathv2 = 'merge/state2'

    def __init__(self, repo):

        self._repo = repo

        self._dirty = False

        self._read()

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

        self._state = {}

        self._local = None

        self._other = None

        if node:

            self._local = node

            self._other = other

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

        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._local = None

        self._other = None

        records = self._readrecords()

        for rtype, record in records:

            if rtype == 'L':

                self._local = bin(record)

            elif rtype == 'O':

                self._other = bin(record)

            elif rtype == 'F':

                bits = record.split('\0')

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

            elif not rtype.islower():

                raise util.Abort(_('unsupported merge state record: %s')

                                   % rtype)

        self._dirty = False

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

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

        for rec in v2records:

            if rec[0] == 'L':

                oldv2.add(rec)

            elif rec[0] == 'F':

                # drop the onode data (not contained in v1)

                oldv2.add(('F', _droponode(rec[1])))

        for rec in v1records:

            if rec not in oldv2:

                # 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(('O', 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] == 'F':

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

                        bits.insert(-2, '')

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

                return v1records

        else:

            return v2records

    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(('L', l[:-1]))

                else:

                    records.append(('F', 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

        returns list of record [(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

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

                off += 4

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

                off += length

                records.append((rtype, record))

            f.close()

        except IOError as err:

            if err.errno != errno.ENOENT:

                raise

        return records

    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."

        """

        # Check local variables before looking at filesystem for performance

        # reasons.

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

               self._repo.vfs.exists(self.statepathv1) or \

               self._repo.vfs.exists(self.statepathv2)

    def commit(self):

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

        if self._dirty:

            records = []

            records.append(('L', hex(self._local)))

            records.append(('O', hex(self._other)))

            for d, v in self._state.iteritems():

                records.append(('F', '\0'.join([d] + v)))

            self._writerecords(records)

            self._dirty = False

    def _writerecords(self, records):

        """Write current state on disk (both v1 and v2)"""

        self._writerecordsv1(records)

        self._writerecordsv2(records)

    def _writerecordsv1(self, records):

        """Write current state on disk in a version 1 file"""

        f = self._repo.vfs(self.statepathv1, 'w')

        irecords = iter(records)

        lrecords = irecords.next()

        assert lrecords[0] == 'L'

        f.write(hex(self._local) + '\n')

        for rtype, data in irecords:

            if rtype == 'F':

                f.write('%s\n' % _droponode(data))

        f.close()

    def _writerecordsv2(self, records):

        """Write current state on disk in a version 2 file"""

        f = self._repo.vfs(self.statepathv2, 'w')

        for key, data in records:

            assert len(key) == 1

            format = '>sI%is' % len(data)

            f.write(_pack(format, key, len(data), data))

        f.close()

    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.

        """

        hash = util.sha1(fcl.path()).hexdigest()

        self._repo.vfs.write('merge/' + hash, fcl.data())

        self._state[fd] = ['u', hash, fcl.path(),

                           fca.path(), hex(fca.filenode()),

                           fco.path(), hex(fco.filenode()),

                           fcl.flags()]

        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] == 'u':

                yield f

    def resolve(self, dfile, wctx, labels=None):

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

        if self[dfile] == 'r':

            return 0

        stateentry = self._state[dfile]

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

        octx = self._repo[self._other]

        fcd = wctx[dfile]

        fco = octx[ofile]

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

        # "premerge" x flags

        flo = fco.flags()

        fla = fca.flags()

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

            if fca.node() == nullid:

                self._repo.ui.warn(_('warning: cannot merge flags for %s\n') %

                                   afile)

            elif flags == fla:

                flags = flo

        # restore local

        f = self._repo.vfs('merge/' + hash)

        self._repo.wwrite(dfile, f.read(), flags)

        f.close()

        r = filemerge.filemerge(self._repo, self._local, lfile, fcd, fco, fca,

                                labels=labels)

        if r is None:

            # no real conflict

            del self._state[dfile]

            self._dirty = True

        elif not r:

            self.mark(dfile, 'r')

        return r

def _checkunknownfile(repo, wctx, mctx, f, f2=None):

    if f2 is None:

        f2 = f

    return (os.path.isfile(repo.wjoin(f))

        and repo.wvfs.audit.check(f)

        and repo.dirstate.normalize(f) not in repo.dirstate

        and mctx[f2].cmp(wctx[f]))

def _checkunknownfiles(repo, wctx, mctx, force, actions):

    """

    Considers any actions that care about the presence of conflicting unknown

    files. For some actions, the result is to abort; for others, it is to

    choose a different action.

    """

    aborts = []

    if not force:

        for f, (m, args, msg) in actions.iteritems():

            if m in ('c', 'dc'):

                if _checkunknownfile(repo, wctx, mctx, f):

                    aborts.append(f)

            elif m == 'dg':

                if _checkunknownfile(repo, wctx, mctx, f, args[0]):

                    aborts.append(f)

    for f in sorted(aborts):

        repo.ui.warn(_("%s: untracked file differs\n") % f)

    if aborts:

        raise util.Abort(_("untracked files in working directory differ "

                           "from files in requested revision"))

    for f, (m, args, msg) in actions.iteritems():

        if m == 'c':

            actions[f] = ('g', args, msg)

        elif m == 'cm':

            fl2, anc = args

            different = _checkunknownfile(repo, wctx, mctx, f)

            if different:

                actions[f] = ('m', (f, f, None, False, anc),

                              "remote differs from untracked local")

            else:

                actions[f] = ('g', (fl2,), "remote created")

def _forgetremoved(wctx, mctx, branchmerge):

    """

    Forget removed files

    If we're jumping between revisions (as opposed to merging), and if

    neither the working directory nor the target rev has the file,

    then we need to remove it from the dirstate, to prevent the

    dirstate from listing the file when it is no longer in the

    manifest.

    If we're merging, and the other revision has removed a file

    that is not present in the working directory, we need to mark it

    as removed.

    """

    actions = {}

    m = 'f'

    if branchmerge: