# Standard library imports.
from pathlib import Path
from urllib.parse import urlencode
from functools import cmp_to_key

# Django imports.
from django.http import HttpResponseNotFound
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect

# Project imports.
from .utils import make_thumbnail, is_image_file

###########################################################################################
# Constants.                                                                              #
###########################################################################################

SORT_OPTIONS = [
    ("abc", "Alphabetical A-Z"),
    ("cba", "Alphabetical Z-A"),
    ("old", "Creation date old to new"),
    ("new", "Creation date new to old"),
    ("recent", "Modification date most recent"),
    ("tnecer", "Modification date least recent"),
]

SORT_LABELS = dict(SORT_OPTIONS)

###########################################################################################
# Helper functions.                                                                       #
###########################################################################################


def normalize_sort(sort_value):
    return sort_value if sort_value in SORT_LABELS else "abc"


def normalize_theme(theme_value):
    return theme_value if theme_value in ("dark", "light") else "dark"


def get_creation_timestamp(path_obj):
    try:
        stat_data = path_obj.stat()
        return getattr(stat_data, "st_birthtime", stat_data.st_ctime)
    except OSError:
        return 0


def get_modification_timestamp(path_obj):
    try:
        return path_obj.stat().st_mtime
    except OSError:
        return 0


def build_query(search_text, sort_key, theme):
    query = {"sort": sort_key, "theme": theme}

    if search_text != "":
        query["search"] = search_text

    return query


def append_query(url, query_dict):
    if len(query_dict) == 0:
        return url

    return url + "?" + urlencode(query_dict)


def gallery_url(path_obj=None, is_dir=False, query_dict=None):
    if query_dict is None:
        query_dict = {}

    if path_obj is None:
        base_url = "/gallery/"
    else:
        path_text = str(path_obj).replace("\\", "/")
        base_url = "/gallery/" + path_text

        if is_dir and not base_url.endswith("/"):
            base_url += "/"

    return append_query(base_url, query_dict)


def do_recursive_search(start_path, query):
    """
    Gets all images and sub-directories inside the start_path whose name matches the given query,
    and then joins the results recursively by iterating in each sub-directory.
    """

    try:
        entries = [entry for entry in start_path.iterdir() if not entry.is_symlink()]
    except OSError:
        return [], []

    all_subdirs = sorted(
        [entry for entry in entries if entry.is_dir()],
        key=lambda item: (item.name.lower(), str(item).lower()),
    )

    subdirs = [entry for entry in all_subdirs if query.lower() in entry.name.lower()]

    images = sorted(
        [
            entry
            for entry in entries
            if entry.is_file()
            and is_image_file(entry)
            and query.lower() in entry.name.lower()
        ],
        key=lambda item: (item.name.lower(), str(item).lower()),
    )

    for subdir in all_subdirs:
        rec_subdirs, rec_images = do_recursive_search(subdir, query.lower())
        subdirs.extend(rec_subdirs)
        images.extend(rec_images)

    return subdirs, images


def sort_images(images, sort_key):
    def compare(img_a, img_b):
        name_a = img_a.name.lower()
        name_b = img_b.name.lower()
        rel_a = str(img_a.relative_to(settings.GALLERY_ROOT)).lower()
        rel_b = str(img_b.relative_to(settings.GALLERY_ROOT)).lower()

        if sort_key == "abc":
            if name_a < name_b:
                return -1
            if name_a > name_b:
                return 1

        elif sort_key == "cba":
            if name_a > name_b:
                return -1
            if name_a < name_b:
                return 1

        elif sort_key == "old":
            created_a = get_creation_timestamp(img_a)
            created_b = get_creation_timestamp(img_b)

            if created_a < created_b:
                return -1
            if created_a > created_b:
                return 1

        elif sort_key == "new":
            created_a = get_creation_timestamp(img_a)
            created_b = get_creation_timestamp(img_b)

            if created_a > created_b:
                return -1
            if created_a < created_b:
                return 1

        elif sort_key == "recent":
            modified_a = get_modification_timestamp(img_a)
            modified_b = get_modification_timestamp(img_b)

            if modified_a > modified_b:
                return -1
            if modified_a < modified_b:
                return 1

        elif sort_key == "tnecer":
            modified_a = get_modification_timestamp(img_a)
            modified_b = get_modification_timestamp(img_b)

            if modified_a < modified_b:
                return -1
            if modified_a > modified_b:
                return 1

        if name_a < name_b:
            return -1
        if name_a > name_b:
            return 1
        if rel_a < rel_b:
            return -1
        if rel_a > rel_b:
            return 1
        return 0

    return sorted(images, key=cmp_to_key(compare))


def build_breadcrumbs(path_text, query_dict):
    breadcrumbs = [{"label": "Gallery", "path": gallery_url(None, True, query_dict)}]

    if path_text == "":
        return breadcrumbs

    segments = Path(path_text).parts
    current = Path("")

    for segment in segments:
        current = current.joinpath(segment)
        breadcrumbs.append(
            {"label": segment, "path": gallery_url(current, True, query_dict)}
        )

    return breadcrumbs


def build_sort_options(request, search_text, sort_key, theme):
    options = []

    for option_key, label in SORT_OPTIONS:
        query = {"sort": option_key, "theme": theme}

        if search_text != "":
            query["search"] = search_text

        options.append(
            {
                "key": option_key,
                "label": label,
                "url": append_query(request.path, query),
                "is_active": option_key == sort_key,
            }
        )

    return options


def get_first_image_thumbnail_url(subdir):
    try:
        images = sorted(
            [
                entry
                for entry in subdir.iterdir()
                if entry.is_file() and not entry.is_symlink() and is_image_file(entry)
            ],
            key=lambda item: (
                item.name.lower(),
                str(item.relative_to(settings.GALLERY_ROOT)).lower(),
            ),
        )
    except OSError:
        return None

    if len(images) == 0:
        return None

    first_image = images[0]

    try:
        make_thumbnail(first_image)
        rel_path = first_image.relative_to(settings.GALLERY_ROOT)
        thumb_path = settings.THUMBNAILS_ROOT.joinpath(rel_path)

        if thumb_path.exists():
            return "/thumbs/" + str(rel_path).replace("\\", "/")
    except Exception:
        pass

    return None


###########################################################################################
# View functions.                                                                         #
###########################################################################################


@login_required
def index(request):
    return redirect("gallery_view_root")


def _render_directory(request, path_text, full_path):
    """
    Renders the gallery view related to directories, be it the contents of an actual directory
    in the file system, or logical gallery directories like search result pages.
    """

    search_text = request.GET.get("search", "").strip()
    sort_key = normalize_sort(request.GET.get("sort", "abc"))
    theme = normalize_theme(request.GET.get("theme", "dark"))
    query_state = build_query(search_text, sort_key, theme)

    try:
        current_entries = [
            entry for entry in full_path.iterdir() if not entry.is_symlink()
        ]
    except OSError:
        return HttpResponseNotFound("Not found")

    current_subdirs = sorted(
        [entry for entry in current_entries if entry.is_dir()],
        key=lambda item: (
            item.name.lower(),
            str(item.relative_to(settings.GALLERY_ROOT)).lower(),
        ),
    )

    if search_text == "":
        images = [
            entry
            for entry in current_entries
            if entry.is_file() and is_image_file(entry)
        ]
    else:
        _, images = do_recursive_search(full_path, search_text)

    images = sort_images(images, sort_key)

    image_data = []
    for image in images:
        rel_path = image.relative_to(settings.GALLERY_ROOT)
        image_url = gallery_url(rel_path, False, query_state)

        thumbnail = None
        try:
            make_thumbnail(image)
            thumb_path = settings.THUMBNAILS_ROOT.joinpath(rel_path)
            if thumb_path.exists():
                thumbnail = "/thumbs/" + str(rel_path).replace("\\", "/")
        except Exception:
            pass

        image_data.append(
            {"path": image_url, "name": image.name, "thumbnail": thumbnail}
        )

    subdir_data = []
    for subdir in current_subdirs:
        rel_path = subdir.relative_to(settings.GALLERY_ROOT)
        subdir_data.append(
            {
                "path": gallery_url(rel_path, True, query_state),
                "name": subdir.name,
                "thumbnail": get_first_image_thumbnail_url(subdir),
            }
        )

    next_theme = "light" if theme == "dark" else "dark"
    theme_query = {"sort": sort_key, "theme": next_theme}

    if search_text != "":
        theme_query["search"] = search_text

    search_action_query = {"sort": sort_key, "theme": theme}

    context = {
        "path": path_text,
        "search_text": search_text,
        "theme": theme,
        "sort_key": sort_key,
        "sort_label": SORT_LABELS[sort_key],
        "sort_options": build_sort_options(request, search_text, sort_key, theme),
        "breadcrumbs": build_breadcrumbs(path_text, query_state),
        "images": image_data,
        "subdirs": subdir_data,
        "theme_toggle_url": append_query(request.path, theme_query),
        "search_action_url": append_query(request.path, search_action_query),
    }

    return render(request, "gallery_view.html", context)


def _render_image(request, path_text, full_path):
    """
    Renders the view corresponding to an image file.
    """

    image = Path("/imgs/").joinpath(path_text)
    img_dir = full_path.parent

    try:
        siblings = [
            entry.name
            for entry in img_dir.iterdir()
            if entry.is_file() and not entry.is_symlink() and is_image_file(entry)
        ]
    except OSError:
        return HttpResponseNotFound("Not found")

    images = sorted(siblings, key=lambda item: item.lower())

    if image.name not in images:
        return HttpResponseNotFound("Not found")

    index = images.index(image.name)
    previous = index - 1 if index > 0 else None
    following = index + 1 if index < len(images) - 1 else None

    context = {
        "image_path": image,
        "prev": images[previous] if previous is not None else None,
        "next": images[following] if following is not None else None,
    }

    return render(request, "image_view.html", context)


@login_required
def gallery_view(request, path=None):
    """
    Shows a list of subdirectories and image files inside the given path.
    The path should be inside the GALLERY_ROOT path, otherwise a 404 error will be thrown.
    """

    root = settings.GALLERY_ROOT.resolve()

    try:
        candidate = root.joinpath(path).resolve() if path is not None else root
        candidate.relative_to(root)
    except Exception:
        return HttpResponseNotFound("Not found")

    if not candidate.exists():
        return HttpResponseNotFound("Not found")

    path_text = path if path is not None else ""

    if candidate.is_dir():
        return _render_directory(request, path_text, candidate)

    return _render_image(request, path_text, candidate)