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

import locale

import os

import re

import signal

import struct

import sys

import tempfile

from .i18n import _

from . import (

    encoding,

    error,

    patch as patchmod,

)

# This is required for ncurses to display non-ASCII characters in default user

# locale encoding correctly.  --immerrr

locale.setlocale(locale.LC_ALL, '')

# os.name is one of: 'posix', 'nt', 'dos', 'os2', 'mac', or 'ce'

if os.name == 'posix':

    import curses

    import fcntl

    import termios

else:

    # I have no idea if wcurses works with crecord...

    try:

        import wcurses as curses

    except ImportError:

        # wcurses is not shipped on Windows by default

        pass

try:

    curses

except NameError:

    if os.name != 'nt':  # Temporary hack to get running on Windows again

        raise error.Abort(

            _('the python curses/wcurses module is not available/installed'))

_origstdout = sys.__stdout__ # used by gethw()

class patchnode(object):

    """abstract class for patch graph nodes

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

    """

    def firstchild(self):

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

    def lastchild(self):

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

    def allchildren(self):

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

        raise NotImplementedError("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("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("method must be implemented by subclass")

    def parentitem(self):

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

    def nextitem(self, constrainlevel=True, skipfolded=True):

        """

        If constrainLevel == True, 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 constrainLevel == False, then 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 constrainlevel:

            return self.nextsibling()

        elif 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, constrainlevel=True, skipfolded=True):

        """

        If constrainLevel == True, 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 constrainLevel == False, then try to return the previous 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 items

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

        next item.

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

        """

        if constrainlevel:

            return self.prevsibling()

        else:

            # 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 = cStringIO.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()[0] == '+'])

        rem = len([l for l in self.changedlines if l.applied

                   and l.prettystr()[0] == '-'])

        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] == '\\ no newline at end of file\n':

            contextlen -= 1

        fromlen = contextlen + self.removed

        tolen = contextlen + self.added

        # diffutils manual, section "2.2.2.2 detailed description of unified

        # format": "an empty hunk is considered to end at the line that

        # precedes the hunk."

        #

        # so, if either of hunks is empty, decrease its line start. --immerrr

        # but only do this if fromline > 0, to avoid having, e.g fromline=-1.

        fromline, toline = self.fromline, self.toline

        if fromline != 0:

            if fromlen == 0:

                fromline -= 1

            if tolen == 0:

                toline -= 1

        fromtoline = '@@ -%d,%d +%d,%d @@%s\n' % (

            fromline, fromlen, toline, tolen,

            self.proc and (' ' + self.proc))

        return fromtoline

    def write(self, fp):

        # updated self.added/removed, which are used by getfromtoline()

        self.added, self.removed = self.countchanges()

        fp.write(self.getfromtoline())

        hunklinelist = []

        # add the following to the list: (1) all applied lines, and

        # (2) all unapplied removal lines (convert these to context lines)

        for changedline in self.changedlines:

            changedlinestr = changedline.prettystr()

            if changedline.applied:

                hunklinelist.append(changedlinestr)

            elif changedlinestr[0] == "-":

                hunklinelist.append(" " + changedlinestr[1:])

        fp.write(''.join(self.before + hunklinelist + self.after))