default persistent.cggallery = []

init python:
    # GALLERY OBJECT
    # Handles unlockables via ren'py
    g = Gallery()
    g.transition = dissolve

    # CONST PARAMS
    GALLERY_COLS = 3
    GALLERY_CGS_PER_PAGE = 6
    PREFERRED_WIDTH = 432 #px (1920 * 0.225)
    PREFERRED_HEIGHT = 243 #px (1080 * 0.225)
    DEFAULT_WIDTH_SCALE_RATIO = round(float(PREFERRED_WIDTH) / float(1920), 4)
    DEFAULT_HEIGHT_SCALE_RATIO = round(float(PREFERRED_HEIGHT) / float(1080), 4)
    NOT_UNLOCKED_COVER = im.FactorScale("gui/gallery/unlocked_cg_button_cover.png", DEFAULT_WIDTH_SCALE_RATIO, DEFAULT_HEIGHT_SCALE_RATIO)
    ACCEPTED_EXTENSIONS = ["jpg", "png"]

    # GALLERY ITEMS
    # Data structure that holds the data for each cg and button
    # item is the key in the Gallery
    # ext is the file extension
    # { item: string; cg: Displayable; ext: string }[]
    galleryItems = []

    # Which page of the gallery is shown
    galleryPage = 1

    # Global function to unlock a cg
    # fname should be a key used in galleryItems
    # (fname: string) -> None
    def unlockCg(fname):
        unlocked = fname in persistent.cggallery
        if unlocked:
            return

        # Save to renpy persistent data
        tmp = list(persistent.cggallery).copy()
        tmp.append(fname)
        persistent.cggallery = tmp
        renpy.persistent.save()
        # TODO: fix unlocking without game reset

        # Rebuild the gallery
        for i in range(0, len(galleryItems) - 1):
            if fname == str(galleryItems[i]["item"]):
                loadGallery()
                return

    # Make a scaled cg button
    # (cg: string; ext: string; w: float; h: float; unlocked?: boolean): Displayable
    def cg(fname, ext, w, h, unlocked = False):
        if not unlocked:
            return NOT_UNLOCKED_COVER

        scaleFactor = getBoxNormalizerRatio(w, h)
        return im.FactorScale("images/cgs/" + fname + "." + ext, scaleFactor["x"], scaleFactor["y"])

    # Create an object in g:Gallery, add to galleryItems
    # (imageName: string; ext: string; w: float; h: float; unlocked?: boolean) -> None
    def addGalleryItem(imageName, ext, w, h, unlocked = False):
        g.button(imageName)
        g.image(imageName)

        horizontalPan = Pan((w - 1920, h - 1080), (0, h - 1080), 30.0)
        verticalPan = Pan((w - 1920, h - 1080), (w - 1920, 0), 30.0)
        g.transform(horizontalPan if w > h else verticalPan) #TODO: niceify

        if unlocked:
            g.unlock(imageName)
            g.condition("True")
        else:
            g.condition("False")

        galleryItems.append({
            "item": imageName,
            "cg": cg(imageName, ext, w, h, unlocked),
            "ext": ext
        })

    # Reads /images/cgs dir for all image files
    # Populates g:Gallery and galleryItems
    # Appends extra spaces at the end
    # () -> None
    def loadGallery():

        cgPath = "images/cgs/"
        lazy_counter = 0

        # Reset gallery
        galleryItems = []
        g = Gallery()
        g.transition = dissolve

        list_img = renpy.list_images()

        # Add each image to the gallery
        for str in list_img:
            _str = cgPath+str+"."+ACCEPTED_EXTENSIONS[0]
            if renpy.loadable(_str): #brute force
                unlocked = renpy.seen_image(str)
                image = renpy.image_size(Image(_str))
                addGalleryItem(str, ACCEPTED_EXTENSIONS[0], image[0], image[1], unlocked)
                lazy_counter += 1

        # Add empty items to fill grid after last cg button
        extraSpaces = GALLERY_COLS - (lazy_counter % GALLERY_COLS)
        for i in range(0, extraSpaces):
            galleryItems.append({
                "item": None,
                "cg": None,
                "ext": None
            })

    # Returns what params to call im.FactorScale with for cg button size
    # Basically the delta diff dimensions
    # (w: int; h: int) -> { x: float; y: float }
    def getBoxNormalizerRatio(w, h):
        x = round(float(PREFERRED_WIDTH) / float(w), 4)
        y = round(float(PREFERRED_HEIGHT) / float(h), 4)

        return { "x": x, "y": y }


    # Returns the pageth slice from galleryItems
    # (page: int): Partial<typeof galleryItems>
    def getGalleryPage(page):
        start = (page - 1) * GALLERY_CGS_PER_PAGE
        end = start + GALLERY_CGS_PER_PAGE
        return galleryItems[start:end]

    # Call to loading the gallery
    loadGallery()



## CG Gallery screen ########################################################
## A screen that shows the image gallery
screen cg_gallery():
    tag menu
    use game_menu(_("Gallery"), scroll="viewport"):

        fixed:
            $ pageItems = getGalleryPage(galleryPage)
            $ galleryRows = len(pageItems) / GALLERY_COLS
            $ maxPage = len(galleryItems) / GALLERY_CGS_PER_PAGE
            vbox:
                hbox:
                    grid GALLERY_COLS galleryRows:

                        spacing gui.slot_spacing

                        # Iterate through galleryItems and add cgs buttons
                        for item in pageItems:
                            if item["item"] == None:
                                hbox
                            else:
                                add g.make_button(item["item"], item["cg"], xalign = 0.5, yalign = 0.5)

                grid 3 1:
                    if galleryPage > 1:
                        textbutton "<" action SetVariable("galleryPage", galleryPage - 1)
                    else:
                        hbox

                    label str(galleryPage)

                    if galleryPage < maxPage:
                        textbutton ">" action SetVariable("galleryPage", galleryPage + 1)
                    else:
                        hbox