# monotone.py - monotone support for the convert extension

#

#  Copyright 2008, 2009 Mikkel Fahnoe Jorgensen <mikkel@dvide.com> and

#  others

#

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

import re

from mercurial.i18n import _

from mercurial.pycompat import open

from mercurial import (

    error,

    pycompat,

)

from mercurial.utils import dateutil

from . import common

class monotone_source(common.converter_source, common.commandline):

    def __init__(self, ui, repotype, path=None, revs=None):

        common.converter_source.__init__(self, ui, repotype, path, revs)

        if revs and len(revs) > 1:

            raise error.Abort(

                _(

                    b'monotone source does not support specifying '

                    b'multiple revs'

                )

            )

        common.commandline.__init__(self, ui, b'mtn')

        self.ui = ui

        self.path = path

        self.automatestdio = False

        self.revs = revs

        norepo = common.NoRepo(

            _(b"%s does not look like a monotone repository") % path

        )

        if not os.path.exists(os.path.join(path, b'_MTN')):

            # Could be a monotone repository (SQLite db file)

            try:

                f = open(path, b'rb')

                header = f.read(16)

                f.close()

            except IOError:

                header = b''

            if header != b'SQLite format 3\x00':

                raise norepo

        # regular expressions for parsing monotone output

        space = br'\s*'

        name = br'\s+"((?:\\"|[^"])*)"\s*'

        value = name

        revision = br'\s+\[(\w+)\]\s*'

        lines = br'(?:.|\n)+'

        self.dir_re = re.compile(space + b"dir" + name)

        self.file_re = re.compile(

            space + b"file" + name + b"content" + revision

        )

        self.add_file_re = re.compile(

            space + b"add_file" + name + b"content" + revision

        )

        self.patch_re = re.compile(

            space + b"patch" + name + b"from" + revision + b"to" + revision

        )

        self.rename_re = re.compile(space + b"rename" + name + b"to" + name)

        self.delete_re = re.compile(space + b"delete" + name)

        self.tag_re = re.compile(space + b"tag" + name + b"revision" + revision)

        self.cert_re = re.compile(

            lines + space + b"name" + name + b"value" + value

        )

        attr = space + b"file" + lines + space + b"attr" + space

        self.attr_execute_re = re.compile(

            attr + b'"mtn:execute"' + space + b'"true"'

        )

        # cached data

        self.manifest_rev = None

        self.manifest = None

        self.files = None

        self.dirs = None

        common.checktool(b'mtn', abort=False)

    def mtnrun(self, *args, **kwargs):

        if self.automatestdio:

            return self.mtnrunstdio(*args, **kwargs)

        else:

            return self.mtnrunsingle(*args, **kwargs)

    def mtnrunsingle(self, *args, **kwargs):

        kwargs['d'] = self.path

        return self.run0(b'automate', *args, **kwargs)

    def mtnrunstdio(self, *args, **kwargs):

        # Prepare the command in automate stdio format

        kwargs = pycompat.byteskwargs(kwargs)

        command = []

        for k, v in pycompat.iteritems(kwargs):

            command.append(b"%d:%s" % (len(k), k))

            if v:

                command.append(b"%d:%s" % (len(v), v))

        if command:

            command.insert(0, b'o')

            command.append(b'e')

        command.append(b'l')

        for arg in args:

            command.append(b"%d:%s" % (len(arg), arg))

        command.append(b'e')

        command = b''.join(command)

        self.ui.debug(b"mtn: sending '%s'\n" % command)

        self.mtnwritefp.write(command)

        self.mtnwritefp.flush()

        return self.mtnstdioreadcommandoutput(command)

    def mtnstdioreadpacket(self):

        read = None

        commandnbr = b''

        while read != b':':

            read = self.mtnreadfp.read(1)

            if not read:

                raise error.Abort(_(b'bad mtn packet - no end of commandnbr'))

            commandnbr += read

        commandnbr = commandnbr[:-1]

        stream = self.mtnreadfp.read(1)

        if stream not in b'mewptl':

            raise error.Abort(

                _(b'bad mtn packet - bad stream type %s') % stream

            )

        read = self.mtnreadfp.read(1)

        if read != b':':

            raise error.Abort(_(b'bad mtn packet - no divider before size'))

        read = None

        lengthstr = b''

        while read != b':':

            read = self.mtnreadfp.read(1)

            if not read:

                raise error.Abort(_(b'bad mtn packet - no end of packet size'))

            lengthstr += read

        try:

            length = pycompat.long(lengthstr[:-1])

        except TypeError:

            raise error.Abort(

                _(b'bad mtn packet - bad packet size %s') % lengthstr

            )

        read = self.mtnreadfp.read(length)

        if len(read) != length:

            raise error.Abort(

                _(

                    b"bad mtn packet - unable to read full packet "

                    b"read %s of %s"

                )

                % (len(read), length)

            )

        return (commandnbr, stream, length, read)

    def mtnstdioreadcommandoutput(self, command):

        retval = []

        while True:

            commandnbr, stream, length, output = self.mtnstdioreadpacket()

            self.ui.debug(

                b'mtn: read packet %s:%s:%d\n' % (commandnbr, stream, length)

            )

            if stream == b'l':

                # End of command

                if output != b'0':

                    raise error.Abort(

                        _(b"mtn command '%s' returned %s") % (command, output)

                    )

                break

            elif stream in b'ew':

                # Error, warning output

                self.ui.warn(_(b'%s error:\n') % self.command)

                self.ui.warn(output)

            elif stream == b'p':

                # Progress messages

                self.ui.debug(b'mtn: ' + output)

            elif stream == b'm':

                # Main stream - command output

                retval.append(output)

        return b''.join(retval)

    def mtnloadmanifest(self, rev):

        if self.manifest_rev == rev:

            return

        self.manifest = self.mtnrun(b"get_manifest_of", rev).split(b"\n\n")

        self.manifest_rev = rev

        self.files = {}

        self.dirs = {}

        for e in self.manifest:

            m = self.file_re.match(e)

            if m:

                attr = b""

                name = m.group(1)

                node = m.group(2)

                if self.attr_execute_re.match(e):

                    attr += b"x"

                self.files[name] = (node, attr)

            m = self.dir_re.match(e)

            if m:

                self.dirs[m.group(1)] = True

    def mtnisfile(self, name, rev):

        # a non-file could be a directory or a deleted or renamed file

        self.mtnloadmanifest(rev)

        return name in self.files

    def mtnisdir(self, name, rev):

        self.mtnloadmanifest(rev)

        return name in self.dirs

    def mtngetcerts(self, rev):

        certs = {

            b"author": b"<missing>",

            b"date": b"<missing>",

            b"changelog": b"<missing>",

            b"branch": b"<missing>",

        }

        certlist = self.mtnrun(b"certs", rev)

        # mtn < 0.45:

        #   key "test@selenic.com"

        # mtn >= 0.45:

        #   key [ff58a7ffb771907c4ff68995eada1c4da068d328]

        certlist = re.split(br'\n\n {6}key ["\[]', certlist)

        for e in certlist:

            m = self.cert_re.match(e)

            if m:

                name, value = m.groups()

                value = value.replace(br'\"', b'"')

                value = value.replace(br'\\', b'\\')

                certs[name] = value

        # Monotone may have subsecond dates: 2005-02-05T09:39:12.364306

        # and all times are stored in UTC

        certs[b"date"] = certs[b"date"].split(b'.')[0] + b" UTC"

        return certs

    # implement the converter_source interface:

    def getheads(self):

        if not self.revs:

            return self.mtnrun(b"leaves").splitlines()

        else:

            return self.revs

    def getchanges(self, rev, full):

        if full:

            raise error.Abort(

                _(b"convert from monotone does not support --full")

            )

        revision = self.mtnrun(b"get_revision", rev).split(b"\n\n")

        files = {}

        ignoremove = {}

        renameddirs = []

        copies = {}

        for e in revision:

            m = self.add_file_re.match(e)

            if m:

                files[m.group(1)] = rev

                ignoremove[m.group(1)] = rev

            m = self.patch_re.match(e)

            if m:

                files[m.group(1)] = rev

            # Delete/rename is handled later when the convert engine

            # discovers an IOError exception from getfile,

            # but only if we add the "from" file to the list of changes.

            m = self.delete_re.match(e)

            if m:

                files[m.group(1)] = rev

            m = self.rename_re.match(e)

            if m:

                toname = m.group(2)

                fromname = m.group(1)

                if self.mtnisfile(toname, rev):

                    ignoremove[toname] = 1

                    copies[toname] = fromname

                    files[toname] = rev

                    files[fromname] = rev

                elif self.mtnisdir(toname, rev):

                    renameddirs.append((fromname, toname))

        # Directory renames can be handled only once we have recorded

        # all new files

        for fromdir, todir in renameddirs:

            renamed = {}

            for tofile in self.files:

                if tofile in ignoremove:

                    continue

                if tofile.startswith(todir + b'/'):

                    renamed[tofile] = fromdir + tofile[len(todir) :]

                    # Avoid chained moves like:

                    # d1(/a) => d3/d1(/a)

                    # d2 => d3

                    ignoremove[tofile] = 1

            for tofile, fromfile in renamed.items():

                self.ui.debug(

                    b"copying file in renamed directory from '%s' to '%s'"

                    % (fromfile, tofile),

                    b'\n',

                )

                files[tofile] = rev

                copies[tofile] = fromfile

            for fromfile in renamed.values():

                files[fromfile] = rev

        return (files.items(), copies, set())

    def getfile(self, name, rev):

        if not self.mtnisfile(name, rev):

            return None, None

        try:

            data = self.mtnrun(b"get_file_of", name, r=rev)

        except Exception:

            return None, None

        self.mtnloadmanifest(rev)

        node, attr = self.files.get(name, (None, b""))

        return data, attr

    def getcommit(self, rev):

        extra = {}

        certs = self.mtngetcerts(rev)

        if certs.get(b'suspend') == certs[b"branch"]:

            extra[b'close'] = b'1'

        dateformat = b"%Y-%m-%dT%H:%M:%S"

        return common.commit(

            author=certs[b"author"],

            date=dateutil.datestr(dateutil.strdate(certs[b"date"], dateformat)),

            desc=certs[b"changelog"],

            rev=rev,

            parents=self.mtnrun(b"parents", rev).splitlines(),

            branch=certs[b"branch"],

            extra=extra,

        )

    def gettags(self):

        tags = {}

        for e in self.mtnrun(b"tags").split(b"\n\n"):

            m = self.tag_re.match(e)

            if m:

                tags[m.group(1)] = m.group(2)

        return tags