# -*- coding: utf-8 -*-
#
#   Copyright © 2017 markdown-link-style contributors.
#
#    This file is part of markdown-link-style.
#
#   markdown-link-style is free software: you can redistribute it
#   and/or modify it under the terms of the GNU General Public License
#   as published by the Free Software Foundation, either version 3 of
#   the License, or (at your option) any later version.
#
#   markdown-link-style is distributed in the hope that it will be
#   useful, but WITHOUT ANY WARRANTY; without even the implied
#   warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
#   See the GNU General Public License for more details.
#
#   You should have received a copy of the GNU General Public License
#   along with markdown-link-style (see COPYING).  If not, see
#   <http://www.gnu.org/licenses/>.

import argparse
import re

from mistune import BlockGrammar, BlockLexer, InlineLexer, Renderer, Markdown

from markdown_link_style.logging import MDLSLogger
from markdown_link_style._version import __version__


# Initialize logger for this module.
logger = MDLSLogger(__name__)


# from mistune
_inline_tags = [
    "a",
    "em",
    "strong",
    "small",
    "s",
    "cite",
    "q",
    "dfn",
    "abbr",
    "data",
    "time",
    "code",
    "var",
    "samp",
    "kbd",
    "sub",
    "sup",
    "i",
    "b",
    "u",
    "mark",
    "ruby",
    "rt",
    "rp",
    "bdi",
    "bdo",
    "span",
    "br",
    "wbr",
    "ins",
    "del",
    "img",
    "font",
]
_valid_end = r"(?!:/|[^\w\s@]*@)\b"
_block_tag = r"(?!(?:%s)\b)\w+%s" % ("|".join(_inline_tags), _valid_end)


def _pure_pattern(regex):
    """Function from mistune."""
    pattern = regex.pattern
    if pattern.startswith("^"):
        pattern = pattern[1:]
    return pattern


class LSBlockGrammar(BlockGrammar):
    def __init__(self):
        # remove list_block and block_quote from paragraph
        self.paragraph = re.compile(
            r"^((?:[^\n]+\n?(?!"
            r"%s|%s|%s|%s|%s|%s|%s"
            r"))+)\n*"
            % (
                _pure_pattern(self.fences).replace(r"\1", r"\2"),
                _pure_pattern(self.hrule),
                _pure_pattern(self.heading),
                _pure_pattern(self.lheading),
                _pure_pattern(self.def_links),
                _pure_pattern(self.def_footnotes),
                "<" + _block_tag,
            )
        )


class LSBlockLexer(BlockLexer):
    """Link Style Block Lexer.

    """

    grammar_class = LSBlockGrammar

    def __init__(self, rules=None, **kwargs):
        super(LSBlockLexer, self).__init__(rules, **kwargs)

        # Only parse these block rules.
        self.default_rules = ["def_links", "paragraph", "text"]


class LSInlineLexer(InlineLexer):
    """Link Style Inline Lexer.

    """

    def __init__(self, renderer, rules=None, **kwargs):
        super(LSInlineLexer, self).__init__(renderer, rules, **kwargs)

        # Only parse these inline rules
        self.default_rules = ["autolink", "link", "reflink", "text"]


class LSRenderer(Renderer):
    """Link Style Renderer.

    """

    def __init__(self, **kwargs):
        super(LSRenderer, self).__init__(**kwargs)

        # Link style is either 'inline' or 'footnote'.
        self.link_style = self.options.get("link_style")

        self.fn_lnk_num = 0  # footnote style link number
        self.fn_lnk_refs = []  # footnote style link refs

    def text(self, text):
        return text

    def autolink(self, link, is_email=False):
        return "<{}>".format(link)

    def paragraph(self, text):
        p = text
        fn_refs = self._pop_fn_refs()

        if fn_refs:
            # Insert footnote refs, if any, after paragraph.
            return "\n{}\n\n{}".format(p, fn_refs)

        return "\n{}\n".format(p)

    def link(self, link, title, text):
        link_text = self._stylize_link(link, title, text)
        return link_text

    def image(self, src, title, text):
        # Markup for images are same as links, except it is prefixed
        # with a bang (!).
        return "{}{}".format("!", self.link(src, title, text))

    def _stylize_link(self, link, title, text):
        if self.link_style == "inline":
            return self._gen_inline_link(link, title, text)
        else:
            return self._gen_footnote_link(link, title, text)

    def _gen_inline_link(self, link, title, text):
        if title:
            return '[{}]({} "{}")'.format(text, link, title)
        else:
            return "[{}]({})".format(text, link)

    def _gen_footnote_link(self, link, title, text):
        fn_num = self._st_fn_ref(link, title)
        return "[{}][{}]".format(text, fn_num)

    def _st_fn_ref(self, link, title):
        """Store footnote link reference.

        """
        fn_num = self._get_fn_lnk_num()

        if title:
            fn_ref = "[{}]: {} ({})".format(fn_num, link, title)
        else:
            fn_ref = "[{}]: {}".format(fn_num, link)

        self.fn_lnk_refs.append(fn_ref)
        return fn_num

    def _get_fn_lnk_num(self):
        """Get footnote link number.

        """
        fn_num = self.fn_lnk_num
        self.fn_lnk_num = self.fn_lnk_num + 1
        return fn_num

    def _pop_fn_refs(self):
        """Pop all footnote refs and return them as a string.

        """
        refs = ""

        for ref in self.fn_lnk_refs:
            refs += "{}\n".format(ref)

        # Empty fn_lnk_refs
        self.fn_lnk_refs = []

        return refs


class LSMarkdown(Markdown):
    """Link Style Markdown parser.
    """

    def __init__(self, renderer=None, inline=None, block=None, **kwargs):
        link_style = kwargs.get("link_style") or "inline"

        if not renderer:
            renderer = LSRenderer(link_style=link_style)
        if not inline:
            inline = LSInlineLexer(renderer)
        if not block:
            block = LSBlockLexer()

        super(LSMarkdown, self).__init__(renderer, inline, block, **kwargs)

    def parse(self, text):
        # Reset footnote link variables.
        self.renderer.fn_lnk_num = 0
        self.renderer.fn_lnk_refs = []

        # Parse text.
        out = super(LSMarkdown, self).parse(text)

        # Spit out.
        return out.lstrip("\n")


class LinkStyler(object):
    """Markdown Link Styler.

    """

    def __init__(self, link_style="inline"):
        self.style = link_style

    def __call__(self, file_):
        return self._link_stylize(file_)

    def _link_stylize(self, file_):
        text = file_.read()
        md = LSMarkdown(link_style=self.style)

        return md(text)


def _write_to(file_, content):
    """Write `content` to `file_`.

        `file_` is expected to be a sub-class of `io.TextIOBase`.
    """
    file_.truncate(0)
    file_.seek(0)
    file_.write(content)
    file_.flush()
    file_.close()


def _mdl_stylize(args):
    ls = LinkStyler(args.link_style)
    stylized_content = ls(args.in_file)

    if args.out_file:
        args.in_file.close()
        _write_to(open(args.out_file, "wt"), stylized_content)
    else:
        _write_to(args.in_file, stylized_content)


def _get_args(args=None):
    parser = argparse.ArgumentParser()
    parser.add_argument("--version", action="version", version=__version__)
    parser.add_argument(
        "link_style", choices=["inline", "footnote"], help="markdown link style."
    )
    parser.add_argument(
        "in_file", type=argparse.FileType("rt+"), help="path to markdown file."
    )
    parser.add_argument(
        "out_file",
        nargs="?",
        type=str,
        default=None,
        help=" ".join(
            [
                "path to output file.",
                "if it is not given, the output is",
                "directly written to the original",
                "in_file.",
            ]
        ),
    )

    return parser.parse_args(args)


def main():
    args = _get_args()
    _mdl_stylize(args)