# vim: fileencoding=utf-8
#
from .base_format import Format, FormatError
from ..template_engine import ParametersContainer
from collections import OrderedDict
import re
try:
    from lxml.etree.ElementTree import fromstring
except ImportError:
    from xml.etree.ElementTree import fromstring


class RegexFormat(Format):
    FORMAT = 'regex'
    EXECUTABLE = False
    FORMAT_PARAMETERS = {'multiline', 'dotall', 'comment'}

    comment_symbol = '#'

    def __init__(self, document_text: str,
                 template_path,
                 ignore_comments=False,
                 join_before=False,
                 add_header=False,
                 already_changed=False,
                 parameters=ParametersContainer(),
                 **kwargs):
        processing_methods = OrderedDict()
        super().__init__(processing_methods)

        self._multiline_flag = parameters.multiline
        self._dotall_flag = parameters.dotall
        if parameters.comment is not False:
            self.comment_symbol = parameters.comment
        self._parsed_patch = None

        if add_header and not ignore_comments:
            self.header, self._document_text, self.shebang =\
                                            self._get_header_and_document_text(
                                               document_text,
                                               template_path,
                                               already_changed=already_changed,
                                               check_shebang=True)
        else:
            self.header = ''
            self.shebang = ''
            self._document_text = document_text
        self._FLAG_VALUES = {'True': True,
                             'False': False,
                             'true': True,
                             'false': False,
                             '1': True,
                             '0': False}

        self._XML_ROOT_LINE = '<?xml version="1.0" encoding="utf-8"?>\
                               <patch>{0}</patch>'

    def _parse_patch(self, patch_text):
        '''Метод, составляющий из текста шаблона xml документ и разбирающий его
        с помощью lxml.'''
        xml_patch = self._XML_ROOT_LINE.format(patch_text.strip())
        try:
            self._parsed_patch = fromstring(xml_patch)
        except Exception:
            raise FormatError('can not parse patch document')

    def join_template(self, template):
        tmp_multiline = template._multiline_flag
        tmp_dotall = template._dotall_flag

        template._multiline_flag = self._multiline_flag
        template._dotall_flag = self._dotall_flag

        self._document_text = template._join(self._document_text)

        template._multiline_flag = tmp_multiline
        template._dotall_flag = tmp_dotall

    def _join(self, input_text):
        '''Метод для запуска наложения патча.'''
        self._parse_patch(self._document_text)

        if not input_text.strip() == '':
            self._document_to_patch = input_text
        else:
            return input_text

        if not self._patch_document(input_text):
            raise FormatError('Error: Can not run patch.')
        else:
            after_patch = self._document_to_patch
            self._document_to_patch = ''

            return after_patch

    def _patch_document(self, document_to_patch):
        '''Метод, обходящий теги шаблона и использующий указанные в нем
        регулярные выражения.'''
        patch_iterator = self._parsed_patch.iter()
        PATCH_DOCUMENT_TAGS = ('reg', 'text')

        patch_element = next(patch_iterator, False)

        if not patch_element or not patch_element.tag == 'patch':
            raise FormatError('incorrect text of the template')

        while True:
            for patch_tag in PATCH_DOCUMENT_TAGS:
                patch_element = next(patch_iterator, None)

                # Предупреждение если отсутствует последний <text>bla</text>
                if patch_element is None:
                    if patch_tag == 'text':
                        raise FormatError('last <text>Text</text> '
                                          'object is missed.')
                    else:
                        break

                if patch_element.tag == patch_tag:
                    # Если <reg> тег пустой -- это ошибка.
                    if patch_element.text is not None:
                        element_text = patch_element.text
                        if patch_tag == "reg" and element_text.strip() == '':
                            raise FormatError(
                                        ("Error: Incorrect text of the "
                                         "template: <{0}>%s</{0}>").format(
                                                                      patch_tag
                                                                           ))
                    elif patch_tag == "reg":
                        raise FormatError("Error: Incorrect text of the "
                                          "template: <{0}></{0}>".format(
                                                                    patch_tag))
                    else:
                        element_text = ''

                    if patch_tag == 'reg':
                        dotall = patch_element.attrib.get('dotall', False)
                        regex_flags = 0

                        if 'multiline' in patch_element.attrib:
                            multiline = patch_element.attrib['multiline']
                            if multiline not in self._FLAG_VALUES:
                                raise FormatError('invalid multiline value')
                            else:
                                multiline = self._FLAG_VALUES[multiline]

                            # Если глобально флаг MULTILINE включен, но в
                            # атрибутах тэга <reg> этот флаг присутствует со
                            # значением False -- для этого регулярного
                            # выражения этот флаг также будет False.
                            multiline_global = self._multiline_flag & multiline
                        else:
                            multiline = False
                            multiline_global = self._multiline_flag

                        if multiline_global or multiline:
                            regex_flags |= re.MULTILINE

                        if 'dotall' in patch_element.attrib:
                            dotall = patch_element.attrib['dotall']
                            if dotall not in self._FLAG_VALUES:
                                raise FormatError('invalid dotall value')
                            else:
                                dotall = self._FLAG_VALUES[dotall]

                            # Если глобально флаг DOTALL включен, но в
                            # атрибутах тэга <reg> этот флаг присутствует со
                            # значением False -- для этого регулярного
                            # выражения этот флаг также будет False.
                            dotall_global = self._dotall_flag & dotall
                        else:
                            dotall = False
                            dotall_global = self._dotall_flag

                        if dotall_global or dotall:
                            regex_flags |= re.DOTALL

                        regex_expression = re.compile(element_text,
                                                      regex_flags)
                    else:
                        text_for_replace = element_text
                else:
                    if patch_element.tag in PATCH_DOCUMENT_TAGS:
                        error_message = '<{0}> is expected, <{1}> instead.'.\
                                            format(patch_tag,
                                                   patch_element.tag)
                    else:
                        error_message = 'unknown tag: {0}'.format(
                                                              patch_element.tag
                                                                 )
                    raise ("incorrect text of the template: {}".format(
                                                                error_message))
            else:
                self._document_to_patch = re.sub(regex_expression,
                                                 text_for_replace,
                                                 self._document_to_patch)
                continue
            return True

    @property
    def document_text(self):
        return '{}{}{}'.format(self.shebang, self.header, self._document_text)