📷 Photography

from pathlib import Path
from PIL import Image, ExifTags


class Photo:
    """
    Represents an image file and provides methods for scaling it down.

    Attributes:
        file (Path): The file path of the image.
        small_file (Path): The file path of the scaled-down image.
        image (PIL.Image): The PIL Image object for the image.
        exif (dict): The exif data for the image.

    Properties:
        size: Returns the size of the image as a tuple of (width, height).
        maker: Returns the maker of the camera that took the image.
        camera: Returns the model of the camera that took the image.
        date: Returns the date and time when the image was taken.

    Methods:
        calc_ratio: Calculates the width and height ratio to scale the image down.
        scale_down: Scales the image down and saves it to the small_file path.
    """

    def __init__(self, file: Path):
        """
        Initializes a Photo object with a file path.

        Args:
            file (Path): The file path of the image.
        """
        self.file = file
        self.small_file = self.file.with_stem(f"{self.file.stem}_small")

        try:
            self.image = Image.open(self.file)
        except OSError:
            print("cannot open", self.file)

        self.exif = self.image.getexif()
        self.exif_data = {ExifTags.TAGS[k]: v for k,v in self.exif.items()}

    @property
    def size(self):
        """
        Returns the size of the image as a tuple of (width, height).

        Returns:
            A tuple of (width, height) for the size of the image.
        """
        return self.image.size

    @property
    def maker(self):
        """
        Returns the maker of the camera that took the image.

        Raises:
            KeyError: If the maker information is not found in the exif data.

        Returns:
            The maker of the camera as a string.
        """
        try:
            return self.exif[271]
        except KeyError:
            print("Could not find maker in exif data", self.file)

    @property
    def camera(self):
        """
        Returns the model of the camera that took the image.

        Raises:
            KeyError: If the camera information is not found in the exif data.

        Returns:
            The model of the camera as a string.
        """
        try:
            return self.exif[272]
        except KeyError:
            print("Could not find camera in exif data", self.file)

    @property
    def date(self):
        """
        Returns the date and time when the image was taken.

        Raises:
            KeyError: If the date information is not found in the exif data.

        Returns:
            The date and time when the image was taken as a string.
        """
        try:
            return self.exif[306]
        except KeyError:
            print("Could not find date in exif data", self.file)

    @staticmethod
    def calc_ratio(max_width: int, size: tuple) -> tuple:
        """
        Calculates the width and height ratio to scale the image down.

        Args:
            max_width (int): The maximum width of the scaled-down image.
            size (tuple): The original size of the image as a (width, height) tuple.

        Returns:
            A tuple of (width, height) to scale the image down.
        """
        return (max_width, int((size[1] / 100) * ((max_width / size[0]) * 100)))

    def scale_down(self) -> Path:
        """
        Scales the image down and saves it to the small_file path.

        Raises:
            OSError: If the file cannot be saved.

        Returns:
            The file path of the scaled-down image.
        """
        im = self.image.resize(self.calc_ratio(992, self.image.size))
        try:
            im.save(self.small_file)
            return self.small_file
        except OSError:
            print("cannot save", self.file)


class PhotoEditor:
    """
    Provides methods for editing multiple photos.

    Attributes:
        wd (Path): The working directory containing the photos.

    Methods:
        photos: Returns a list of Photo objects for all the photos in the working directory.
        scaledown_photos: Returns a list of file paths for scaled-down versions of the photos.
    """

    def __init__(self, wd):
        """
        Initializes a PhotoEditor object with a working directory.

        Args:
            wd (Path): The working directory containing the photos.
        """
        self.wd: Path = wd

    @property
    def photos(self) -> list:
        """
        Returns a list of Photo objects for all the photos in the working directory.

        Returns:
            A list of Photo objects.
        """
        files = []
        for suffix in ["*.jpg", "*.jpeg", "*.JPG"]:
            files += self.wd.glob(suffix)
        photos = []
        for file in files:
            p = Photo(file)
            if "_small" not in p.file.stem and p.date:
                photos.append(p)
        return sorted(photos, key=lambda photo: photo.date)

    def scaledown_photos(self, _photos) -> list:
        """
        Returns a list of file paths for scaled-down versions of the photos.

        Args:
            _photos (list): A list of Photo objects.

        Returns:
            A list of file paths for the scaled-down images.
        """
        scaled_photos = []
        for photo in _photos:
            if "_small" not in photo.file.stem:
                scaled_photos.append([photo.scale_down(),
                                      photo.size,
                                      photo.maker,
                                      photo.camera,
                                      photo.date])
        return scaled_photos

from pathlib import Path
from photoeditor import PhotoEditor


def generate_html(items: list) -> str:
    html_list = '<ul class="photo-collection">'
    for photo in items:
        html_img = '<li class="item">'
        html_img += f'<img class="photography photo" src="./{photo[0]}"/>'
        html_img += f'<ul class="photo-property"><li>{photo[1]}</li><li>{photo[2]}</li><li>{photo[3]}</li><li>{photo[4]}</li></ul>'
        html_img += '</li>'
        html_list += html_img
    html_list += "</ul>"
    return html_list


pe = PhotoEditor(Path(wd))
print(generate_html(pe.scaledown_photos(pe.photos)))

/**
 * Creates and returns a new zoomContainer div and zoomImg img DOM elements.
 *
 * @returns {Object} An object containing the newly created zoomContainer and zoomImg elements.
 */
function createZoomElements() {
    let zoomContainer = document.createElement("div");
    let zoomImg = document.createElement("img");
    zoomImg.className = "zoom-img";
    zoomContainer.id = "zoom-container";

    return { zoomContainer, zoomImg };
}

/**
 * Sets up a click event listener on a zoomContainer element to hide the
 * zoomContainer and clear the zoomImg source.
 *
 * @param {HTMLElement} zoomContainer - The zoomContainer div to add the event listener to.
 * @param {HTMLElement} zoomImg - The zoomImg img whose source will be cleared when the zoomContainer is clicked.
 */
function setZoomContainerListener(zoomContainer, zoomImg) {
    zoomContainer.addEventListener("click", () => {
        zoomContainer.style.display = "none";
        zoomImg.src = "";
    });
}

/**
 * Sets up click event listeners on all elements with the class "photo" to
 * toggle the display of the zoomContainer and set the zoomImg source to the
 * clicked photo's source.
 *
 * @param {HTMLElement} zoomContainer - The zoomContainer div to toggle the display of.
 * @param {HTMLElement} zoomImg - The zoomImg img to set the source of.
 */
function setPhotosListener(zoomContainer, zoomImg) {
    document.querySelectorAll(".photo").forEach((photo) => {
        photo.addEventListener("click", () => {
            if (zoomContainer.style.display === "flex") {
                zoomContainer.style.display = "none";
            } else {
                zoomImg.src = photo.src.replace("_small", "");
                zoomContainer.style.display = "flex";

                if (!zoomContainer.querySelector(".zoom-img")) {
                    zoomContainer.appendChild(zoomImg);
                }

                document.body.appendChild(zoomContainer);
            }
        });
    });
}

/**
 * On window load, creates zoomContainer and zoomImg elements, sets up a click
 * event listener on the zoomContainer, and sets up click event listeners on
 * all photos to toggle the zoom functionality.
 */
window.onload = () => {
    const { zoomContainer, zoomImg } = createZoomElements();
    setZoomContainerListener(zoomContainer, zoomImg);
    setPhotosListener(zoomContainer, zoomImg);
};