import logging
from pelican import signals

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

logger = logging.getLogger(__name__)


IMAGE_PATH = './content/'
IMAGE_SIZES = [200, 375, 480, 800, 1600]


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
    logger.info("start\n\n")
    content = "" + content

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

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

    m = find_between(content, '[lightgallery', 'lightgalleryend]')

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

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

        logger.info("t\'" + img_url + "\'a\'" + img_text + "\'\n")
        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 IMAGE_SIZES[1:-1]:
            new_url = "" + str(Path(img_url).parent) + "/" + str(i) + "/" + str(Path(img_url).name)
            logger.info("t\'" + new_url + "\n")
            # create_scaled_image(IMAGE_PATH + img_url, IMAGE_PATH + new_url, i)
            imgs_text += "" + new_url + ", "

        imgs_text += "\" "

        imgs_text += "data-src=\""
        imgs_text += img_url
        imgs_text += "\" "

        imgs_text += "data-sub-html=\""
        imgs_text += img_text
        imgs_text += "<p>"
        imgs_text += create_exif_print(IMAGE_PATH + 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>"
    logger.info("" + replace_text + "\n")
    content = content.replace('[lightgallery' + m + 'lightgalleryend]', replace_text)
    article._content = content
    logger.info("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):
    logger.info("add_gallery\n\n")

    # 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.info("gen " + new_path + "from " + org_path + " size " + str(resize_width) + "\n")

    exists = os.path.isfile(new_path)
    if exists:
        logger.info("skip nothing to do\n")
        return ""

    dir_path = str(Path(new_path).parent)
    exists = os.path.isdir(dir_path)
    if not exists:
        logger.info("create dir " + dir_path)
        os.mkdir(dir_path)


    logger.info("convert \n")
    img = PIL.Image.open(org_path)
    width, height = img.size
    logger.info("" + str(width) + "\n")
    if (width > resize_width):
        img = resizeimage.resize_width(img, resize_width)
    img.save(new_path, img.format)
    img.close()
    logger.info("done \n")


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.info("######### 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 register():
    signals.all_generators_finalized.connect(add_gallery)