import logging
from pelican import signals

from pelican.generators import ArticlesGenerator
from pelican.generators import PagesGenerator
from pathlib import Path

logger = logging.getLogger(__name__)


_MAIN_SETTINGS = None        # settings dict of the main Pelican instance


def process_content(article):
    """
    Substitute the citations and add a bibliography for an article or
    page, using the local bib file if specified or the global one otherwise.
    """
    content = article._content
    content = "" + content

    i = content.count("[lightgallery")
    if (i <= 0):
        pass

    j = content.count("lightgalleryend]")
    if (j != i):
        pass

    for i in range(0, i):
        m = find_between(content, '[lightgallery', 'lightgalleryend]')

        imgs = m.split(';')
        logger.debug("" + article.title + "\n")
        imgs_text = ""
        for i in imgs:
            cont = i.split(',')
            img_url = cont[0].strip()
            if img_url == "":
                continue
            img_url = img_url

            img_text = ""
            if (len(cont) > 1):
                img_text = "<h4>" + cont[1] + "</h4>"

            zoom_url = "/theme/images/zoom.png"

            imgs_text += "<li "
            imgs_text += "class=\"col-xs-6 col-sm-4 col-md-3\" "
            imgs_text += "data-responsive=\""

            for i in [375, 480, 800, 1600]:
                imgs_text += "" + _MAIN_SETTINGS['SITEURL'] + str(Path(img_url).parent)
                imgs_text += "/" + str(i) + "/" + str(Path(img_url).name)
                imgs_text += " " + str(i) + ", "

            imgs_text += "\" "

            imgs_text += "data-src=\""
            imgs_text += _MAIN_SETTINGS['SITEURL'] + img_url
            imgs_text += "\" "

            imgs_text += "data-sub-html=\""
            imgs_text += img_text
            imgs_text += "<p>"
            imgs_text += create_exif_print("./content/" + img_url)
            imgs_text += "</p>"
            imgs_text += "\"> "

            imgs_text += "<a href=\"\">"
            imgs_text += "<img class=\"img-responsive\" src=\""
            imgs_text += "" + str(Path(img_url).parent) + "/" + str(200) + "/" + str(Path(img_url).name)
            imgs_text += "\" > "

            imgs_text += " <div class=\"demo-gallery-poster\"> "
            imgs_text += "  <img width=26 src=\"" + zoom_url + "\"> "
            imgs_text += " </div>"

            imgs_text += "</a>"
            imgs_text += "</li>\n"

        replace_text = " <div class=\"demo-gallery\"> "
        replace_text += " <ul id=\"lightgallery\" class=\"list-unstyled row\">"
        replace_text += imgs_text
        replace_text += "</ul>"
        replace_text += "</div>"
        content = content.replace('[lightgallery' + m + 'lightgalleryend]', replace_text)
        article._content = content
    logger.debug("end\n\n")
    pass


def replace_right(source, target, replacement, replacements=None):
    return replacement.join(source.rsplit(target, replacements))


def find_between(s, first, last):
    try:
        start = s.rindex(first) + len(first)
        end = s.rindex(last, start)
        return s[start:end]
    except ValueError:
        return ""


def add_gallery(generators):
    # Process the articles and pages
    for generator in generators:
        if isinstance(generator, ArticlesGenerator):
            for article in (generator.articles + generator.translations + generator.drafts):
                process_content(article)
        elif isinstance(generator, PagesGenerator):
            for page in generator.pages:
                process_content(page)

    pass


def create_scaled_image(org_path, new_path, resize_width):
    import PIL.Image
    from resizeimage import resizeimage
    import os

    logger.debug("gen " + new_path + "from " + org_path + " size " + str(resize_width) + "\n")

    exists = os.path.isfile(new_path)
    if exists:
        return ""

    dir_path = str(Path(new_path).parent)
    exists = os.path.isdir(dir_path)
    if not exists:
        os.mkdir(dir_path)

    img = PIL.Image.open(org_path)
    width, height = img.size
    if (width > resize_width):
        img = resizeimage.resize_width(img, resize_width)
    img.save(new_path, img.format)
    img.close()


def create_exif_print(img_path):
    try:
        import PIL.Image
        import os
        exists = os.path.isfile(img_path)
        if not exists:
            return ""

        img = PIL.Image.open(img_path)
        exif = img._getexif()
        img.close()

        logger.debug("######### exif " + img_path + "\n")

        if exif is None:
            return ""

        programm_dic = {0: "N",  # "Not defined",
                        1: "M",  # "Manual",
                        2: "N",  # "Normal program",
                        3: "A",  # "Aperture priority",
                        4: "S",  # "Shutter priority",
                        5: "C",  # "Creative program",
                        6: "A",  # "Action program",
                        7: "P",  # "Portrait mode",
                        8: "L",  # "Landscape mode",
                        }

        ret = ""
        if 272 in exif:
            ret += "" + exif[272]
            if 42036 in exif:
                ret += " with " + exif[42036]
            ret += "<br>"

        if 37386 in exif:
            ret += "at" + str(exif[37386][0] / exif[37386][1]) + "mm "
        if 37378 in exif:
            ret += "f" + str(exif[37378][0] / exif[37378][1]) + " "

        if 34855 in exif:
            ret += " iso" + str(exif[34855]) + " "
        if 33434 in exif:
            ret += " " + str(exif[33434][0])
            if exif[33434][1] != 1:
                ret += "/" + str(exif[33434][1])
            ret += "sec "

        if 34850 in exif:
            ret += " <bolt>" + programm_dic[exif[34850]] + "</bolt>"

        if 315 in exif:
            ret += " " + exif[315]
            if 33432 in exif:
                ret += " (c) " + exif[33432]

        return ret
    except ValueError:
        return ""


def initialize_plugin(pelican_obj):
    '''Initialize plugin variables and Pelican settings'''
    global _MAIN_SETTINGS
    if _MAIN_SETTINGS is None:
        _MAIN_SETTINGS = pelican_obj.settings


_SIGNAL_HANDLERS_DB = {
    'get_generators': initialize_plugin,
    'all_generators_finalized': add_gallery,
}


def register():
    for sig_name in _SIGNAL_HANDLERS_DB.keys():
        if not hasattr(signals, sig_name):
            logger.error((
                'The i18n_subsites plugin requires the {} '
                'signal available for sure in Pelican 3.4.0 and later, '
                'plugin will not be used.').format(sig_name))
            return

    for sig_name, handler in _SIGNAL_HANDLERS_DB.items():
        sig = getattr(signals, sig_name)
        sig.connect(handler)