# stuff related specifically to patch manipulation / parsing

#

# Copyright 2008 Mark Edgington <edgimar@gmail.com>

#

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

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

#

# This code is based on the Mark Edgington's crecord extension.

# (Itself based on Bryan O'Sullivan's record extension.)

from __future__ import absolute_import

import os

import re

import signal

from .i18n import _

from .pycompat import (

    getattr,

    open,

)

from . import (

    diffhelper,

    encoding,

    error,

    patch as patchmod,

    pycompat,

    scmutil,

    util,

)

from .utils import stringutil

stringio = util.stringio

# patch comments based on the git one

diffhelptext = _(

    b"""# To remove '-' lines, make them ' ' lines (context).

# To remove '+' lines, delete them.

# Lines starting with # will be removed from the patch.

"""

)

hunkhelptext = _(

    b"""#

# If the patch applies cleanly, the edited hunk will immediately be

# added to the record list. If it does not apply cleanly, a rejects file

# will be generated. You can use that when you try again. If all lines

# of the hunk are removed, then the edit is aborted and the hunk is left

# unchanged.

"""

)

patchhelptext = _(

    b"""#

# If the patch applies cleanly, the edited patch will immediately

# be finalised. If it does not apply cleanly, rejects files will be

# generated. You can use those when you try again.

"""

)

try:

    import curses

    import curses.ascii

    curses.error

except (ImportError, AttributeError):

    curses = None

class fallbackerror(error.Abort):

    """Error that indicates the client should try to fallback to text mode."""

    # Inherits from error.Abort so that existing behavior is preserved if the

    # calling code does not know how to fallback.

def checkcurses(ui):

    """Return True if the user wants to use curses

    This method returns True if curses is found (and that python is built with

    it) and that the user has the correct flag for the ui.

    """

    return curses and ui.interface(b"chunkselector") == b"curses"

class patchnode(object):

    """abstract class for patch graph nodes

    (i.e. patchroot, header, hunk, hunkline)

    """

    def firstchild(self):

        raise NotImplementedError(b"method must be implemented by subclass")

    def lastchild(self):

        raise NotImplementedError(b"method must be implemented by subclass")

    def allchildren(self):

        """Return a list of all of the direct children of this node"""

        raise NotImplementedError(b"method must be implemented by subclass")

    def nextsibling(self):

        """

        Return the closest next item of the same type where there are no items

        of different types between the current item and this closest item.

        If no such item exists, return None.

        """

        raise NotImplementedError(b"method must be implemented by subclass")

    def prevsibling(self):

        """

        Return the closest previous item of the same type where there are no

        items of different types between the current item and this closest item.

        If no such item exists, return None.

        """

        raise NotImplementedError(b"method must be implemented by subclass")

    def parentitem(self):

        raise NotImplementedError(b"method must be implemented by subclass")

    def nextitem(self, skipfolded=True):

        """

        Try to return the next item closest to this item, regardless of item's

        type (header, hunk, or hunkline).

        If skipfolded == True, and the current item is folded, then the child

        items that are hidden due to folding will be skipped when determining

        the next item.

        If it is not possible to get the next item, return None.

        """

        try:

            itemfolded = self.folded

        except AttributeError:

            itemfolded = False

        if skipfolded and itemfolded:

            nextitem = self.nextsibling()

            if nextitem is None:

                try:

                    nextitem = self.parentitem().nextsibling()

                except AttributeError:

                    nextitem = None

            return nextitem

        else:

            # try child

            item = self.firstchild()

            if item is not None:

                return item

            # else try next sibling

            item = self.nextsibling()

            if item is not None:

                return item

            try:

                # else try parent's next sibling

                item = self.parentitem().nextsibling()

                if item is not None:

                    return item

                # else return grandparent's next sibling (or None)

                return self.parentitem().parentitem().nextsibling()

            except AttributeError:  # parent and/or grandparent was None

                return None

    def previtem(self):

        """

        Try to return the previous item closest to this item, regardless of

        item's type (header, hunk, or hunkline).

        If it is not possible to get the previous item, return None.

        """

        # try previous sibling's last child's last child,

        # else try previous sibling's last child, else try previous sibling

        prevsibling = self.prevsibling()

        if prevsibling is not None:

            prevsiblinglastchild = prevsibling.lastchild()

            if (prevsiblinglastchild is not None) and not prevsibling.folded:

                prevsiblinglclc = prevsiblinglastchild.lastchild()

                if (

                    prevsiblinglclc is not None

                ) and not prevsiblinglastchild.folded:

                    return prevsiblinglclc

                else:

                    return prevsiblinglastchild

            else:

                return prevsibling

        # try parent (or None)

        return self.parentitem()

class patch(patchnode, list):  # todo: rename patchroot

    """

    list of header objects representing the patch.

    """

    def __init__(self, headerlist):

        self.extend(headerlist)

        # add parent patch object reference to each header

        for header in self:

            header.patch = self

class uiheader(patchnode):

    """patch header

    xxx shouldn't we move this to mercurial/patch.py ?

    """

    def __init__(self, header):

        self.nonuiheader = header

        # flag to indicate whether to apply this chunk

        self.applied = True

        # flag which only affects the status display indicating if a node's

        # children are partially applied (i.e. some applied, some not).

        self.partial = False

        # flag to indicate whether to display as folded/unfolded to user

        self.folded = True

        # list of all headers in patch

        self.patch = None

        # flag is False if this header was ever unfolded from initial state

        self.neverunfolded = True

        self.hunks = [uihunk(h, self) for h in self.hunks]

    def prettystr(self):

        x = stringio()

        self.pretty(x)

        return x.getvalue()

    def nextsibling(self):

        numheadersinpatch = len(self.patch)

        indexofthisheader = self.patch.index(self)

        if indexofthisheader < numheadersinpatch - 1:

            nextheader = self.patch[indexofthisheader + 1]

            return nextheader

        else:

            return None

    def prevsibling(self):

        indexofthisheader = self.patch.index(self)

        if indexofthisheader > 0:

            previousheader = self.patch[indexofthisheader - 1]

            return previousheader

        else:

            return None

    def parentitem(self):

        """

        there is no 'real' parent item of a header that can be selected,

        so return None.

        """

        return None

    def firstchild(self):

        """return the first child of this item, if one exists.  otherwise

        None."""

        if len(self.hunks) > 0:

            return self.hunks[0]

        else:

            return None

    def lastchild(self):

        """return the last child of this item, if one exists.  otherwise

        None."""

        if len(self.hunks) > 0:

            return self.hunks[-1]

        else:

            return None

    def allchildren(self):

        """return a list of all of the direct children of this node"""

        return self.hunks

    def __getattr__(self, name):

        return getattr(self.nonuiheader, name)

class uihunkline(patchnode):

    """represents a changed line in a hunk"""

    def __init__(self, linetext, hunk):

        self.linetext = linetext

        self.applied = True

        # the parent hunk to which this line belongs

        self.hunk = hunk

        # folding lines currently is not used/needed, but this flag is needed

        # in the previtem method.

        self.folded = False

    def prettystr(self):

        return self.linetext

    def nextsibling(self):

        numlinesinhunk = len(self.hunk.changedlines)

        indexofthisline = self.hunk.changedlines.index(self)

        if indexofthisline < numlinesinhunk - 1:

            nextline = self.hunk.changedlines[indexofthisline + 1]

            return nextline

        else:

            return None

    def prevsibling(self):

        indexofthisline = self.hunk.changedlines.index(self)

        if indexofthisline > 0:

            previousline = self.hunk.changedlines[indexofthisline - 1]

            return previousline

        else:

            return None

    def parentitem(self):

        """return the parent to the current item"""

        return self.hunk

    def firstchild(self):

        """return the first child of this item, if one exists.  otherwise

        None."""

        # hunk-lines don't have children

        return None

    def lastchild(self):

        """return the last child of this item, if one exists.  otherwise

        None."""

        # hunk-lines don't have children

        return None

class uihunk(patchnode):

    """ui patch hunk, wraps a hunk and keep track of ui behavior"""

    maxcontext = 3

    def __init__(self, hunk, header):

        self._hunk = hunk

        self.changedlines = [uihunkline(line, self) for line in hunk.hunk]

        self.header = header

        # used at end for detecting how many removed lines were un-applied

        self.originalremoved = self.removed

        # flag to indicate whether to display as folded/unfolded to user

        self.folded = True

        # flag to indicate whether to apply this chunk

        self.applied = True

        # flag which only affects the status display indicating if a node's

        # children are partially applied (i.e. some applied, some not).

        self.partial = False

    def nextsibling(self):

        numhunksinheader = len(self.header.hunks)

        indexofthishunk = self.header.hunks.index(self)

        if indexofthishunk < numhunksinheader - 1:

            nexthunk = self.header.hunks[indexofthishunk + 1]

            return nexthunk

        else:

            return None

    def prevsibling(self):

        indexofthishunk = self.header.hunks.index(self)

        if indexofthishunk > 0:

            previoushunk = self.header.hunks[indexofthishunk - 1]

            return previoushunk

        else:

            return None

    def parentitem(self):

        """return the parent to the current item"""

        return self.header

    def firstchild(self):

        """return the first child of this item, if one exists.  otherwise

        None."""

        if len(self.changedlines) > 0:

            return self.changedlines[0]

        else:

            return None

    def lastchild(self):

        """return the last child of this item, if one exists.  otherwise

        None."""

        if len(self.changedlines) > 0:

            return self.changedlines[-1]

        else:

            return None

    def allchildren(self):

        """return a list of all of the direct children of this node"""

        return self.changedlines

    def countchanges(self):

        """changedlines -> (n+,n-)"""

        add = len(

            [

                l

                for l in self.changedlines

                if l.applied and l.prettystr().startswith(b'+')

            ]

        )

        rem = len(

            [

                l

                for l in self.changedlines

                if l.applied and l.prettystr().startswith(b'-')

            ]

        )

        return add, rem

    def getfromtoline(self):

        # calculate the number of removed lines converted to context lines

        removedconvertedtocontext = self.originalremoved - self.removed

        contextlen = (

            len(self.before) + len(self.after) + removedconvertedtocontext

        )

        if self.after and self.after[-1] == diffhelper.MISSING_NEWLINE_MARKER:

            contextlen -= 1

        fromlen = contextlen + self.removed

        tolen = contextlen + self.added