# vim: sw=4 ts=4 et si:

from enum import Enum
import io
import re
import sys

import suse_git.exc as exc
import suse_git.util as util

class ValidationError(Exception):
    pass

class PatchException(Exception):
    def __init__(self, errors):
        Exception.__init__(self, "Validation Error")
        self._errors = errors

    def errors(self, error=None):
        count = 0
        if error is None:
            return len(self._errors)
        for err in self._errors:
            if isinstance(err, error):
                count += 1
        return count

    def __str__(self):
        return "\n".join("** %s" % str(x) for x in self._errors)

    def __repr__(self):
        ret = "%d errors:\n" % len(self._errors)
        ret += "\n".join(self._errors)
        return ret

    def error_message(self, fn):
        ret = "ERROR: Problems encountered in "
        if fn:
            ret += "`%s'\n" % fn
        else:
            ret += "input\n"

        ret += str(self)

        return ret

class PatchChecker:
    def __init__(self):
        pass

    def do_patch(self):
        pass

class Patch(object):
    # This pattern was copied from quilt/scripts/patchfns.in:patch_header() in
    # the quilt sources
    break_matcher = re.compile(rb"(---|\*\*\*|Index:)[ \t][^ \t]|^diff -")

    def __init__(self, f):
        assert(f.tell() == 0)
        assert(isinstance(f, io.BufferedIOBase)) # binary (bytes) io object

        self.modified = False
        self.f = f
        self.head = []
        self.body = b""
        for line in f:
            if self.break_matcher.match(line):
                self.body = line
                break
            self.head.append(line.decode())


    def __del__(self):
        self.writeback()


    def __enter__(self):
        return self


    def __exit__(self, *args):
        self.writeback()


    def writeback(self):
        if not self.modified:
            return

        self.body = self.body + self.f.read()
        self.f.seek(0)
        self.f.writelines([line.encode() for line in self.head])
        self.f.write(self.body)
        self.f.truncate()

        self.modified = False


    def get(self, tag):
        """
        tag does not contain the terminal ": ". It is case insensitive.

        Returns a list with the value for each instance of the tag.
        """
        start = "%s: " % (tag.lower(),)
        return [line[len(start):].strip()
                for line in self.head
                if line.lower().startswith(start)]

    def get_list_normalized(self, tag):
        """
        Treat tag value (in all instances) as a list of tokens delimited by
        whitespace or commas.

        Returns normalized set of tokens.
        """
        tokens = " ".join(self.get(tag)).replace(",", " ").split()
        return References(tokens)

    def remove(self, tag):
        """
        Removes all instances of the tag.

        tag does not contain the terminal ": ". It is case insensitive.
        """
        if not self.f.writable():
            raise exc.KSException("Modification of read-only Patch")

        if len(self.get(tag)):
            self.modified = True
            start = "%s: " % (tag.lower(),)
            self.head = [line
                         for line in self.head
                         if not line.lower().startswith(start)]


    class ChangeMode(Enum):
        EACH = 1        # change value of each instance
        ALL_WITH_ONE = 2# change value of first instance, drop other

    def change(self, tag, value, mode=ChangeMode.EACH):
        """
        Changes the value of instances of the tag based on mode.

        tag does not contain the terminal ": ". It is case insensitive.
        """
        if not self.f.writable():
            raise exc.KSException("Modification of read-only Patch")

        if len(self.get(tag)):
            self.modified = True
            start = "%s: " % (tag.lower(),)

            replaced = False
            new_head = []
            for line in self.head:
                if not line.lower().startswith(start):
                    new_head.append(line)
                    continue
                if replaced and mode == Patch.ChangeMode.ALL_WITH_ONE:
                    continue
                new_head.append("%s%s\n" % (line[:len(start)], value.strip(),))
                replaced = True
            self.head = new_head
        else:
            raise KeyError("Tag \"%s\" not found" % (tag,))

class References(util.OrderedSet):
    """
    Class represents set of patch references, it is case insensitive and
    order-preserving to avoid unnecessary changes touching patches.
    """
    def __init__(self, iterable=None):
        self.__ci_set = set()
        super().__init__(iterable)

    def add(self, key):
        if key not in self:
            self.__ci_set.add(References._canon(key))
            super().add(key)

    def __contains__(self, key):
        return References._canon(key) in self.__ci_set

    def __eq__(self, other):
        if isinstance(other, References):
            return self.__ci_set == other.__ci_set
        return super().__eq__(other)

    def _canon(val):
        return val.lower()