"""
    unitest base class
    ~~~~~~~~~~~~~~~~~~

    Basic unittest class for all python-creole tests.

    :copyleft: 2008-2020 by python-creole team, see AUTHORS for more details.
    :license: GNU GPL v3 or above, see LICENSE for more details.
"""


import re
import warnings

from creole import creole2html, html2creole, html2rest, html2textile
from creole.exceptions import DocutilsImportError
from creole.tests.utils.utils import MarkupTest

try:
    import textile
except ImportError:
    test_textile = False
    warnings.warn(
        "Markup error: The Python textile library isn't installed."
        " Download: http://pypi.python.org/pypi/textile"
    )
else:
    test_textile = True


try:
    from creole.rest_tools.clean_writer import rest2html
except DocutilsImportError as err:
    REST_INSTALLED = False
    warnings.warn(f"Can't run all ReSt unittests: {err}")
else:
    REST_INSTALLED = True

tabs2spaces_re = re.compile(r"^(\t*)(.*?)$", re.M)


def tabs2spaces(html):
    """ form reformating textile html code
    >>> tabs2spaces("\\t<p>one<br />\\n\\t\\ttwo<br />\\n\\t\\t\\ttree</p>")
    '<p>one<br />\\n  two<br />\\n    tree</p>'
    """
    def reformat_tabs(match):
        tabs = match.group(1)
        text = match.group(2)

        indent = len(tabs) - 1
        if indent < 0:
            indent = 0

#        print(len(tabs), indent, repr(tabs), text)
        return "  " * indent + text
    return tabs2spaces_re.sub(reformat_tabs, html)


def strip_html_lines(html, strip_lines=False):
    """
    >>> strip_html_lines("\t<p>foo   \\n\\n\t\t  bar</p>", strip_lines=True)
    '<p>foo\\nbar</p>'
    """
    html = "\n".join(
        [line.strip(" \t") for line in html.splitlines() if line]
    )
    return html


class BaseCreoleTest(MarkupTest):
    """
    Basic unittest class for all python-creole unittest classes.
    """

    def _debug_text(self, msg, raw_text):
        text = raw_text.replace(" ", ".")
        text = text.replace("\n", "\\n\n")
        text = text.replace("\t", "\\t")

        print()
        print("_" * 79)
        print(f" Debug Text: {msg}:")
        print(text)
        print("-" * 79)

    def assert_creole2html(
        self, raw_creole, raw_html,
        strip_lines=False, debug=True,
        parser_kwargs={}, emitter_kwargs={},
        block_rules=None, blog_line_breaks=True, macros=None, verbose=True, stderr=None,
        strict=False,
    ):
        """
        compare the generated html code from the markup string >creole_string<
        with the >html_string< reference.
        """
        self.assertNotEqual(raw_creole, raw_html)
        self.assertEqual(parser_kwargs, {}, "parser_kwargs is deprecated!")
        self.assertEqual(emitter_kwargs, {}, "parser_kwargs is deprecated!")

        # prepare whitespace on test strings
        markup_string = self._prepare_text(raw_creole)
        assert isinstance(markup_string, str)

        html_string = self._prepare_text(raw_html)
        assert isinstance(html_string, str)
        if strip_lines:
            html_string = strip_html_lines(html_string, strip_lines)
        self._debug_text("assert_creole2html() html_string reference", html_string)

        # convert creole markup into html code
        out_string = creole2html(
            markup_string, debug=debug,
            block_rules=block_rules, blog_line_breaks=blog_line_breaks,
            macros=macros, verbose=verbose, stderr=stderr,
            strict=strict,
        )
        self._debug_text("assert_creole2html() creole2html output", out_string)

        if strip_lines:
            out_string = strip_html_lines(out_string, strip_lines)
        else:
            out_string = out_string.replace("\t", "    ")

        # compare
        self.assertEqual(out_string, html_string, msg="creole2html")

    def assert_html2creole2(self, creole, html,
                            debug=True,
                            unknown_emit=None,
                            strict=False,
                            ):
        # convert html code into creole markup
        out_string = html2creole(
            html, debug, unknown_emit=unknown_emit, strict=strict
        )
        self._debug_text("assert_html2creole() html2creole", out_string)

        # compare
        self.assertEqual(out_string, creole, msg="html2creole")

    def assert_html2creole(self, raw_creole, raw_html,
                           strip_lines=False, debug=True,
                           # OLD API:
                           parser_kwargs={}, emitter_kwargs={},
                           # html2creole:
                           unknown_emit=None,
                           strict=False,
                           ):
        """
        Compare the genereted markup from the given >raw_html< html code, with
        the given >creole_string< reference string.
        """
        self.assertEqual(parser_kwargs, {}, "parser_kwargs is deprecated!")
        self.assertEqual(emitter_kwargs, {}, "parser_kwargs is deprecated!")
#        assert isinstance(raw_html, str)
#        creole_string = unicode(creole_string, encoding="utf8")
#        raw_html = unicode(raw_html, "utf8")

        self.assertNotEqual(raw_creole, raw_html)

        # prepare whitespace on test strings
        creole = self._prepare_text(raw_creole)
        assert isinstance(creole, str)
        if debug:
            self._debug_text("assert_creole2html() markup", creole)

        html = self._prepare_text(raw_html)
        assert isinstance(html, str)

        self.assert_html2creole2(creole, html, debug, unknown_emit, strict)

    def cross_compare_creole(self, creole_string, html_string,
                             strip_lines=False, debug=True,
                             # creole2html old API:
                             creole_parser_kwargs={}, html_emitter_kwargs={},
                             # html2creole old API:
                             html_parser_kwargs={}, creole_emitter_kwargs={},

                             # creole2html new API:
                             block_rules=None, blog_line_breaks=True, macros=None, stderr=None,
                             # html2creole:
                             unknown_emit=None
                             ):
        """
        Cross compare with:
            * creole2html
            * html2creole
        """
        self.assertEqual(creole_parser_kwargs, {}, "creole_parser_kwargs is deprecated!")
        self.assertEqual(html_emitter_kwargs, {}, "html_emitter_kwargs is deprecated!")
        self.assertEqual(html_parser_kwargs, {}, "html_parser_kwargs is deprecated!")
        self.assertEqual(creole_emitter_kwargs, {}, "creole_emitter_kwargs is deprecated!")

        assert isinstance(creole_string, str)
        assert isinstance(html_string, str)
        self.assertNotEqual(creole_string, html_string)

        self.assert_creole2html(
            raw_creole=creole_string, raw_html=html_string,
            strip_lines=strip_lines,
            block_rules=block_rules, blog_line_breaks=blog_line_breaks,
            macros=macros, stderr=stderr,
        )

        self.assert_html2creole(
            raw_creole=creole_string, raw_html=html_string, strip_lines=strip_lines,
            unknown_emit=unknown_emit,
        )

    def assert_html2textile(self, textile_string, html_string,
                            strip_lines=False, debug=False, parser_kwargs={}, emitter_kwargs={}):
        """
        Check html2textile
        """
        self.assertNotEqual(textile_string, html_string)

        textile_string = self._prepare_text(textile_string)
        html_string = self._prepare_text(html_string)

        if strip_lines:
            html_string = strip_html_lines(html_string, strip_lines)

        # compare html -> textile
        textile_string2 = html2textile(html_string, debug, parser_kwargs, emitter_kwargs)
        if debug:
            print("-" * 79)
            print(textile_string2)
            print("-" * 79)

        self.assertEqual(textile_string2, textile_string, msg="html2textile")

        return textile_string, html_string

    def cross_compare_textile(self, textile_string, html_string,
                              strip_lines=False, debug=False, parser_kwargs={}, emitter_kwargs={}):
        """
            Checks:
                * html2textile
                * textile2html
        """
#        assert isinstance(textile_string, str)
#        assert isinstance(html_string, str)
        self.assertNotEqual(textile_string, html_string)

        # compare html -> textile
        textile_string, html_string = self.assert_html2textile(
            textile_string, html_string,
            strip_lines, debug, parser_kwargs, emitter_kwargs
        )

        # compare textile -> html
        if not test_textile:
            # TODO: Use @unittest.skipIf if python 2.6 will be not support anymore
            warnings.warn("Skip textile test. Please install python textile module.")
            return

        html = textile.textile(textile_string)
        html = html.replace("<br />", "<br />\n")
        html = tabs2spaces(html)
        if strip_lines:
            html = strip_html_lines(html, strip_lines)

        self.assertEqual(html_string, html, msg="textile2html")

    def assert_html2rest(self, rest_string, html_string,
                         strip_lines=False, debug=False, parser_kwargs={}, emitter_kwargs={}):
        """
        Check html to reStructuredText converter
        """
        self.assertNotEqual(rest_string, html_string)

        rest_string = self._prepare_text(rest_string)
        print("-" * 100)
        print(rest_string)
        html_string = self._prepare_text(html_string)
        if strip_lines:
            html_string = strip_html_lines(html_string, strip_lines)
        print("-" * 100)
        print(html_string)

        # compare html -> reStructuredText
        rest_string2 = html2rest(html_string, debug, parser_kwargs, emitter_kwargs)
        print("-" * 100)
        print(rest_string2)
        print("-" * 100)

        self.assertEqual(rest_string2, rest_string, msg="html2rest")

        return rest_string, html_string

    def assert_rest2html(self, rest_string, html_string,
                         strip_lines=False, debug=False, prepare_strings=True, **kwargs):

        # compare rest -> html
        if not REST_INSTALLED:
            warnings.warn("Skip ReSt test. Please install Docutils.")
            return

        if prepare_strings:
            rest_string = self._prepare_text(rest_string)
            html_string = self._prepare_text(html_string)

        html = rest2html(rest_string, **kwargs)

        if debug:
            print(rest_string)
            print(html_string)
            print(html)

        html = html.strip()
#        html = html.replace("<br />", "<br />\n")
#        html = tabs2spaces(html)
        if strip_lines:
            html = strip_html_lines(html, strip_lines)

        self.assertEqual(html, html_string, msg="rest2html")

    def cross_compare_rest(self, rest_string, html_string,
                           strip_lines=False, debug=False, parser_kwargs={}, emitter_kwargs={}):
        #        assert isinstance(textile_string, str)
        #        assert isinstance(html_string, str)
        self.assertNotEqual(rest_string, html_string)

        rest_string, html_string = self.assert_html2rest(
            rest_string, html_string,
            strip_lines, debug, parser_kwargs, emitter_kwargs
        )

        # compare rest -> html
        self.assert_rest2html(
            rest_string, html_string,
            strip_lines=strip_lines, debug=debug,
            prepare_strings=False,
        )

    def cross_compare(self,
                      html_string,
                      creole_string=None,
                      textile_string=None,
                      rest_string=None,
                      strip_lines=False, debug=False, parser_kwargs={}, emitter_kwargs={}):
        """
        Cross compare with:
            * creole2html
            * html2creole
            * html2textile
            * html2ReSt
        """
        if creole_string:
            self.cross_compare_creole(
                creole_string, html_string, strip_lines, debug, parser_kwargs, emitter_kwargs
            )

        if textile_string:
            self.cross_compare_textile(
                textile_string, html_string, strip_lines, debug, parser_kwargs, emitter_kwargs
            )

        if rest_string:
            self.cross_compare_rest(
                rest_string, html_string, strip_lines, debug, parser_kwargs, emitter_kwargs
            )


if __name__ == '__main__':
    import doctest
    print(doctest.testmod())