# coding: utf8
"""Useful functions for handling patches in WSIs."""

import os
import numpy
from pathlib import Path
from fastcore.foundation import L, setify
import shutil
from typing import Sequence, List, Optional, Dict
from .types import PathLike


def slides_in_folder(folder: str, extensions: Sequence[str] = (".mrxs",)) -> List[str]:
    """
    Return slide files inside a folder for a given extension.

    Args:
        folder: absolute path to a directory containing slides.
        extension: file extensions of the slides.
    Returns:
        List of absolute paths of slide files.

    """
    abspathlist = []
    for name in os.listdir(folder):

        if not name.startswith("."):
            for extension in extensions:
                if name.endswith(extension):
                    abspathlist.append(os.path.join(folder, name))
    return abspathlist


def slide_basename(slidepath: str) -> str:
    """
    Give the basename of a slide from its absolutepath.

    Args:
        slidepath: absolute path to a slide.

    Returns:
        basename: basename of the slide.

    """
    base = os.path.basename(slidepath)
    basename, ext = os.path.splitext(base)
    return basename


def imfiles_in_folder(
    folder: str,
    authorized: Sequence[str] = (".png", ".jpg", ".jpeg", ".tif", ".tiff"),
    forbiden: Sequence[str] = ("thumbnail",),
    randomize: bool = False,
    datalim: Optional[int] = None,
) -> List[str]:
    """
    Get image files in a given folder.

    Get all image files (selected by file extension). You can remove terms
    from the research.

    Args:
        folder: absolute path to an image directory.
        authorized: authorized image file extensions.
        forbiden: non-authorized words in file names.
        randomize: whether to randomize output list of files.
        datalim: maximum number of file to extract in folder.

    Returns:
        Absolute paths of image files in folder.

    """
    imfiles = []
    for name in os.listdir(folder):
        _, ext = os.path.splitext(name)
        if ext in authorized:
            auth = True
            for forb in forbiden:
                if forb in name:
                    auth = False
            if auth:
                imfiles.append(os.path.join(folder, name))

    if randomize:
        numpy.random.shuffle(imfiles)
    if datalim is not None:
        imfiles = imfiles[0:datalim]

    return imfiles


def dataset2folders(
    projfolder: PathLike,
    level: int,
    randomize: bool = False,
    slide_data_lim: Optional[int] = None,
) -> Dict[str, str]:
    """
    Link slidenames to their pathaia patch folder.

    A pathaia patch folder is named with an int corresponding
    to the level of patch extraction.

    Args:
        projfolder: absolute path to a pathaia project folder.
        level: pyramid level of patch extraction to consider.
        randomize: whether to randomize output list of slides.
        slide_data_lim: number of slides to consider in project.

    Returns:
        Dictionary mapping slidenames and absolute paths to patch dirs.

    """
    slide2folder = dict()
    for slidename in os.listdir(projfolder):
        slide_folder = os.path.join(projfolder, slidename)
        if os.path.isdir(slide_folder):
            level_folder = os.path.join(slide_folder, "level_{}".format(level))
            if os.path.isdir(level_folder):
                slide2folder[slidename] = level_folder

    keep = list(slide2folder.keys())
    if randomize:
        numpy.random.shuffle(keep)
    if slide_data_lim is not None:
        keep = keep[0:slide_data_lim]
    return {k: slide2folder[k] for k in keep}


def _get_files(p, fs, extensions=None):
    p = Path(p)
    res = [
        p / f
        for f in fs
        if not f.startswith(".")
        and ((not extensions) or f'.{f.split(".")[-1].lower()}' in extensions)
    ]
    return res


def get_files(
    path: PathLike,
    extensions: Optional[Sequence[str]] = None,
    recurse: bool = True,
    folders: Optional[Sequence[str]] = None,
    followlinks: bool = True,
) -> List[Path]:
    """
    Find all files in a folder recursively.

    Arguments:
        path: Path to input folder.
        extensions: list of acceptable file extensions.
        recurse: whether to perform a recursive search or not.
        folders: direct subfolders to explore (if None explore all).
        followlinks: whether to follow symlinks or not.

    Returns:
        List of all absolute paths to found files.
    """
    path = Path(path)
    folders = L(folders)
    extensions = setify(extensions)
    extensions = {e.lower() for e in extensions}
    if recurse:
        res = []
        for i, (p, d, f) in enumerate(
            os.walk(path, followlinks=followlinks)
        ):  # returns (dirpath, dirnames, filenames)
            if len(folders) != 0 and i == 0:
                d[:] = [o for o in d if o in folders]
            else:
                d[:] = [o for o in d if not o.startswith(".")]
            if len(folders) != 0 and i == 0 and "." not in folders:
                continue
            res += _get_files(p, f, extensions)
    else:
        f = [o.name for o in os.scandir(path) if o.is_file()]
        res = _get_files(path, f, extensions)
    return L(res)


def safe_rmtree(
    path: PathLike, ignore_errors: bool = True, erase_tree: Optional[bool] = None
) -> bool:
    """
    Safe version of rmtree that asks for permission before deleting.

    Arguments:
        path: path to folder to be deleted.
        ignore_error: whether to ignore errors or not.
        erase_tree: whether to remove tree or not. If None asks for permission.

    Returns:
        True if erase_tree==True or if user gave permission.
    """
    response = ""
    if erase_tree is None:
        while response not in ["y", "n"]:
            response = input(
                "Are you sure you want to delete " f"{path} and all subfolders ? y/n"
            )
            response = response.lower()

    if response == "y" or erase_tree:
        shutil.rmtree(path, ignore_errors=ignore_errors)
        return True
    else:
        return False