default wardrobe_music = False
default wardrobe_chitchats = True
default wardrobe_autosave = False
default wardrobe_suppress_warnings = False
default wardrobe_randomise_color = False
default wardrobe_global_color = False

# Used as custom order for the sorting
define wardrobe_subcategories_sorted = {
    "hair": 5, "shirts": 5, "skirts": 5, "pantyhose": 5, "slot1": 5, "panties": 5, "save": 5,
    "earrings": 4, "sweaters": 4, "trousers": 4, "stockings": 4, "bikini panties": 4, "load": 4,
    "neckwear": 3, "dresses": 3, "shorts": 3, "socks": 3, "schedule": 3,
    "one-piece suits": 2, "import": 2,
    "robes": 1, "export": 1,
    "gloves": 0, "pubes": 0, "delete": 0,
    "other": -1,
}

define wardrobe_categories = ("head", "piercings & tattoos", "upper body", "upper undergarment", "lower body", "lower undergarment", "legwear", "misc")
define wardrobe_outfit_schedule = ("day", "night", "cloudy", "rainy", "snowy")
default __lock = False
default __predicted = None

init python:
    def preload_wardrobe_assets(c):
        global __lock, __predicted

        if renpy.version_tuple < (8, 2):
            renpy.start_predict_screen("wardrobe")
        else:
            # use the new renpy.invoke_in_main_thread
            renpy.invoke_in_main_thread(renpy.start_predict_screen, "wardrobe")

        # this is not thread-safe, but there's no better way : it's the slow part
        d = [v[0] for i in c.wardrobe_list for v in i.get_layers(i._hash).values()]

        if renpy.version_tuple < (8, 2):
            renpy.start_predict(*d, "interface/wardrobe/*.webp")
        else:
            renpy.invoke_in_main_thread(renpy.start_predict, *d, "interface/wardrobe/*.webp")
        __predicted = d
        __lock = False

    def rebuild_wardrobe_icons(items, subcat):
        if not settings.get("multithreading"):
            return

        if subcat == "import":
            return

        for i in items.get(subcat, []):
            i.build_button(subcat)

    def lock_wardrobe_icon(icon):
        if not settings.get("multithreading"):
            return icon

        lock = bool(DollThread._count)

        return gray_tint(icon) if lock else icon

    def randomise_wardrobe_color(cloth):

        def _func(cloth):
            if not cloth is None:
                if wardrobe_randomise_color and cloth.color:
                    col_len = len(cloth.color)
                    col = []

                    for i in range(col_len):
                        if col_len == 1:
                            col.append(tetriadic_colors[0])
                        elif col_len == 2:
                            col.append(double_colors[i-1])
                        elif col_len == 3:
                            col.append(triadic_colors[i-1])
                        else:
                            try:
                                col.append(tetriadic_colors[i-1])
                            except:
                                col.append(col[-1].rotate_hue(0.33))

                    cloth.set_color(col)

                    if wardrobe_global_color:
                        for outfit in char_active.outfits:
                            rebuild = False

                            for i in outfit.group:
                                if not (i.id, i.type) == (cloth.id, cloth.type):
                                    continue

                                if len(cloth.color) != len(i.color):
                                    print(f"Mismatched color lens:\n{cloth}\n{i}")
                                    renpy.notify("Error!")
                                    continue

                                i.set_color(cloth.color)
                                i.is_stale()
                                rebuild = True

                            if rebuild:
                                outfit.is_stale()

                    rebuild_wardrobe_icons(category_items, current_subcategory)

        if settings.get("multithreading"):
            thread = DollThread(target=_func, args=(cloth,), interval=0.05)
            thread.start()
        else:
            _func(cloth)
            renpy.restart_interaction()

    # @functools.cache # Cache resets on wardrobe exit
    def set_wardrobe_categories(current_category):
        category_items = OrderedDict(
            sorted(
                [
                    (subcat, [item for item in items if item.unlocked])
                    for subcat, items in wardrobe_subcategories.get(current_category, {}).items()
                ],
                key=lambda x: wardrobe_subcategories_sorted.get(x[0], 0),
                reverse=True
            )
        )
        return category_items

style loading_text:
    color "#ffffff"
    size 64

style loading_trivia_text:
    color "#ffffff"
    size 24

layeredimage loading:
    always "gui_fade"
    always Text("Loading", style="loading_text"):
        align (0.5, 0.35)
    always "loading_spinner"

image loading_spinner:
    align (0.5, 0.5)

    Text("{unicode}╞╪═════════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═╪════════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞══╪═══════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═══╪══════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞════╪═════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═════╪════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞══════╪═══╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═══════╪══╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞════════╪═╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═════════╪╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞════════╪═╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═══════╪══╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞══════╪═══╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═════╪════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞════╪═════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═══╪══════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞══╪═══════╡{/unicode}", style="loading_text")
    pause 0.1
    Text("{unicode}╞═╪════════╡{/unicode}", style="loading_text")
    pause 0.1
    repeat

label wardrobe:
    $ renpy.call_in_new_context("_wardrobe")
    return

label _wardrobe:
    $ renpy.config.skipping = None
    $ _game_menu_screen = None
    $ _skipping = False
    $ renpy.suspend_rollback(True)
    show loading zorder 1000

    # Ensure there's no thread in use before assigning a new one.
    while __lock:
        $ renpy.pause(0.5, hard=True)

    $ __lock = True
    $ renpy.invoke_in_thread(preload_wardrobe_assets, get_character_object(states.active_girl))

    # Await thread return
    # Note: renpy.pause must be called from within the main thread
    while __lock:
        $ renpy.pause(0.5, predict=True)

    hide loading

    # $ renpy.scene("screens")
    # show expression screenshot.image
    call wardrobe_menu

    show screen main_room
    $ _game_menu_screen = "navigation"
    $ _skipping = True
    $ renpy.stop_predict(__predicted)
    $ __predicted = None
    $ renpy.suspend_rollback(False)
    $ renpy.block_rollback()
    return

screen wardrobe(xx, yy):
    tag wardrobe
    zorder 24
    add "gui_fade"

    if renpy.mobile:
        use close_button_background
    use close_button

    fixed:
        use wardrobe_menu(xx, yy)
        if current_category == "outfits":
            use wardrobe_outfit_menuitem(20, 50)
        elif current_subcategory is not None:
            use wardrobe_menuitem(20, 50)

label wardrobe_menu():
    $ renpy.dynamic(
        char_active = get_character_object(states.active_girl),
        char_outfit = get_character_outfit(states.active_girl, typ="last"),
    )
    $ char_outfit.save()

    $ renpy.dynamic(
        wardrobe_subcategories = char_active.wardrobe,
        current_category = "head",
    )
    python:
        if renpy.android:
            wardrobe_subcategories.update(outfits=dict.fromkeys(("load", "save", "delete", "schedule"), char_active.outfits))
        else:
            wardrobe_subcategories.update(outfits=dict.fromkeys(("load", "save", "delete", "schedule", "import", "export"), char_active.outfits))

    $ renpy.dynamic(
        category_items = set_wardrobe_categories(current_category),
    )
    $ renpy.dynamic(
        current_subcategory = next(iter(category_items), ""),
    )
    $ renpy.dynamic(
        current_item = char_active.get_equipped_wardrobe_item(category_items, current_subcategory),
        last_track = renpy.music.get_playing(),
    )
    $ rebuild_wardrobe_icons(category_items, current_subcategory)

    if wardrobe_music:
        play music "music/Spring_In_My_Step.ogg" fadein 1 if_changed

    show screen wardrobe(662, 50)

    label .after_init:

    $ renpy.hide(get_character_tag(states.active_girl))
    $ renpy.config.skipping = None
    $ _game_menu_screen = None
    $ _skipping = False
    $ renpy.suspend_rollback(True)
    $ renpy.block_rollback()

    # Note to self: Do not use a python: block, because
    # renpy cannot return to the middle of a python block
    # while mixing python and renpy scope
    # https://github.com/renpy/renpy/issues/959

    $ renpy.dynamic(__choice = ui.interact())

    if __choice[0] == "category":
        if not current_category == __choice[1]:
            if wardrobe_check_category(__choice[1]):
                $ current_category = __choice[1]

                $ category_items = set_wardrobe_categories(current_category)
                $ current_subcategory = list(category_items.keys())[0] if category_items else ""

                if current_category == "outfits":
                    $ char_active.clear_outfit_button_cache()

                $ current_item = char_active.get_equipped_wardrobe_item(category_items, current_subcategory)

                $ char_active.wear("all")
                if current_category in ("lower undergarment", "upper undergarment"):
                    $ char_active.strip("top", "bottom", "robe", "accessory")
                elif current_category == "piercings & tattoos":
                    $ char_active.strip("top", "bottom", "robe", "accessory", "bra", "panties", "stockings", "gloves")
            else:
                $ wardrobe_react("category_fail", __choice[1])

            $ rebuild_wardrobe_icons(category_items, current_subcategory)

    elif __choice[0] == "subcategory":
        if not current_subcategory == __choice[1]:
            $ current_subcategory = __choice[1]

            if current_category == "outfits":
                $ char_active.clear_outfit_button_cache()

            $ current_item = char_active.get_equipped_wardrobe_item(category_items, current_subcategory)

            $ rebuild_wardrobe_icons(category_items, current_subcategory)

    elif __choice[0] == "equip":
        ### CLOTHING ###
        if isinstance(__choice[1], DollCloth):
            if __choice[1].type == "hair" and char_active.is_equipped_item(__choice[1]):
                play sound "sounds/fail.ogg"
                $ renpy.notify("Hair cannot be removed.")
            else:

                if char_active.is_equipped_item(__choice[1]):
                    # UNEQUIP
                    if wardrobe_check_unequip(__choice[1]):
                        $ wardrobe_react("unequip", __choice[1])
                        $ char_active.unequip(__choice[1])

                        if current_item:
                            $ current_item.clear_button_cache()
                            $ current_item.build_button()

                        $ current_item = None
                    else:
                        $ wardrobe_react("unequip_fail", __choice[1])
                else:
                    # EQUIP
                    if wardrobe_check_equip(__choice[1]):
                        $ wardrobe_react("equip", __choice[1])

                        # Blacklist handling
                        if not wardrobe_check_blacklist(__choice[1]):
                            $ wardrobe_react("blacklist", __choice[1])

                        $ __choice[1].mark_as_seen()
                        $ char_active.equip(__choice[1])

                        if current_item:
                            $ current_item.clear_button_cache()
                            $ current_item.build_button()

                        $ current_item = __choice[1]
                        $ current_item.clear_button_cache()
                        $ current_item.build_button()

                        if wardrobe_fallback_required(__choice[1]):
                            # Has to be called regardless of player preference.
                            $ renpy.call(get_character_response(states.active_girl, "fallback"), __choice[1])
                    else:
                        $ wardrobe_react("equip_fail", __choice[1])

        ### OUTFIT ###
        elif isinstance(__choice[1], DollOutfit):
            $ _outfit = char_active.create_outfit(temp=True)

            if _outfit == __choice[1]:
                $ renpy.notify("Load failed: Outfit already equipped.")
            else:
                if wardrobe_check_equip_outfit(__choice[1]):

                    if not _outfit.exists():
                        $ _confirmed = wardrobe_suppress_warnings or renpy.call_screen("confirm", "Discard unsaved changes and load this outfit?")

                        if _confirmed:
                            $ wardrobe_react("equip_outfit", __choice[1])
                            $ char_active.equip(__choice[1])
                            $ current_item = __choice[1]
                        else:
                            $ renpy.notify("Load failed: Cancelled by user.")
                    else:
                        $ wardrobe_react("equip_outfit", __choice[1])
                        $ char_active.equip(__choice[1])
                        $ current_item = __choice[1]
                else:
                    $ wardrobe_react("equip_outfit_fail", __choice[1])

    elif __choice[0] == "setcolor":
        python:
            current_item.set_color(__choice[1])
            current_item.clear_button_cache()
            current_item.build_button()

            if wardrobe_global_color:
                for outfit in char_active.outfits:
                    rebuild = False

                    for i in outfit.group:
                        if not i.id == current_item.id:
                            continue

                        i.set_color(current_item.color)
                        i.is_stale()
                        rebuild = True

                    if rebuild:
                        outfit.is_stale()

    elif __choice[0] == "touch":
        if wardrobe_check_touch(__choice[1]):
            $ wardrobe_react("touch", __choice[1])
        else:
            $ wardrobe_react("touch_fail", __choice[1])

    elif __choice[0] == "addoutfit":
        python:
            _outfit = char_active.create_outfit(temp=True)

            if _outfit.exists():
                renpy.notify("Save failed: Outfit already exists.")
            else:
                if __choice[1]:
                    _index = char_active.outfits.index(__choice[1])
                    _confirmed = wardrobe_suppress_warnings or renpy.call_screen("confirm", "Overwrite this outfit?")

                    if _confirmed:
                        _old_outfit = char_active.outfits[_index]
                        _old_schedule = _old_outfit.schedule.copy()

                        _outfit = char_active.create_outfit()
                        _outfit.delete() # Removes it from list only
                        _outfit.schedule = _old_schedule

                        char_active.outfits[_index] = _outfit
                        _outfit.build_button(current_subcategory)
                        renpy.notify("Overwritten.")
                    else:
                        renpy.notify("Save failed: Cancelled by user.")

                else:
                    _outfit = char_active.create_outfit()
                    _outfit.build_button(current_subcategory)
                    renpy.notify("Outfit Saved.")

                current_item = char_active.get_equipped_wardrobe_item(category_items, current_subcategory)

            category_items = set_wardrobe_categories(current_category)

    elif __choice[0] == "deloutfit":
        python:
            _confirmed = wardrobe_suppress_warnings or renpy.call_screen("confirm", "Delete this outfit?")

            if _confirmed:
                __choice[1].delete()
                category_items = set_wardrobe_categories(current_category)
                renpy.notify("Outfit Deleted.")

    elif __choice[0] == "export":
        python:
            filename = renpy.input("Save as:", datetime.datetime.now().strftime("%d %b %Y-%H%M%S"))

            if not filename.endswith(".png"):
                filename += ".png"

            __choice[1].export_data(filename)
            achievements.unlock("export")

    elif __choice[0] == "import":
        $ _outfit = char_active.import_outfit(__choice[1])
        $ category_items = set_wardrobe_categories(current_category)

    elif __choice[0] == "schedule":
        $ renpy.call_screen("wardrobe_schedule_menuitem", __choice[1])

    elif __choice == "music":
        python:
            if wardrobe_music:
                wardrobe_music = False
                renpy.music.play(last_track)
            else:
                wardrobe_music = True
                renpy.music.play("music/Spring_In_My_Step.ogg", fadein=1)

    elif __choice == "randomise":
        python:
            _confirmed = False

            _outfit = char_active.create_outfit(temp=True)

            if not _outfit.exists():
                _confirmed = wardrobe_suppress_warnings or renpy.call_screen("confirm", "Randomise Outfit?\n{size=-6}Unsaved changes will be lost.{/size}")

                if not _confirmed:
                    renpy.notify("Advice: If you want to keep an outfit, save it.")
                    renpy.jump("wardrobe_menu.after_init")

            progress = get_character_progression(states.active_girl)

            if wardrobe_randomise_color:
                # Set once per interaction
                tetriadic_colors = [Color("%06x" % random.randint(0, 0xFFFFFF))]
                triadic_colors = [tetriadic_colors[0].rotate_hue(0.25)]
                double_colors = [tetriadic_colors[0], tetriadic_colors[0].rotate_hue(0.5)]

                for i in range(1, 3):
                    col = tetriadic_colors[0].rotate_hue((i * 90.0) / 360.0)
                    tetriadic_colors.append(col)

                    col = triadic_colors[i-1].rotate_hue((i * 75.0) / 360.0)
                    triadic_colors.append(col)

            for k in dict(char_active.states).keys():
                valid_choices = [x for x in char_active.wardrobe_list if (istype(x, (DollCloth, DollClothDynamic, DollMakeup)) and x.type == k and x.unlocked and progress >= x.level)]

                if k == "panties":
                    if not progress >= get_character_requirement(states.active_girl, "category lower undergarment"):
                        continue

                    if progress >= get_character_requirement(states.active_girl, "unequip panties"):
                        valid_choices += [None]
                elif k == "bra":
                    if not progress >= get_character_requirement(states.active_girl, "category upper undergarment"):
                        continue

                    if progress >= get_character_requirement(states.active_girl, "unequip bra"):
                        valid_choices += [None]
                elif k == "top":
                    if progress >= get_character_requirement(states.active_girl, "unequip top"):
                        valid_choices += [None]
                elif k == "bottom":
                    if progress >= get_character_requirement(states.active_girl, "unequip bottom"):
                        valid_choices += [None]
                elif any(k.startswith(type) for type in ("piercing", "tattoo")):
                    if not progress >= get_character_requirement(states.active_girl, "category piercings & tattoos"):
                        continue

                    valid_choices += [None]
                elif k == "hair":
                    pass
                elif k in char_active.body_layers:
                    pass
                else:
                    valid_choices += [None]

                if valid_choices:
                    cloth = random.choice(valid_choices)

                    if cloth:
                        randomise_wardrobe_color(cloth)
                        char_active.equip(cloth)
                    else:
                        char_active.unequip(k)

            if current_item:
                current_item.clear_button_cache()
                current_item.build_button(current_subcategory)

            current_item = char_active.get_equipped_wardrobe_item(category_items, current_subcategory)

            if current_item:
                current_item.clear_button_cache()
                current_item.build_button(current_subcategory)

    else: #__choice == "Close":
        python:
            _confirmed = False

            if wardrobe_autosave:
                _outfit = char_active.create_outfit()
            else:
                _outfit = char_active.create_outfit(temp=True)

                if not _outfit.exists():
                    renpy.notify("Advice: If you want to keep an outfit, save it.")
                    _confirmed = wardrobe_suppress_warnings or renpy.call_screen("confirm", "Exit without saving?\n{size=-6}Unsaved changes will be lost.{/size}")

                    if not _confirmed:
                        renpy.jump("wardrobe_menu.after_init")

                    char_active.equip(char_outfit)

                    if wardrobe_global_color:
                        for cloth in char_outfit.group:
                            for outfit in char_active.outfits:
                                rebuild = False

                                for i in outfit.group:
                                    if not (i.id, i.type) == (cloth.id, cloth.type):
                                        continue

                                    i.set_color(cloth.color)
                                    i.is_stale()
                                    rebuild = True

                                if rebuild:
                                    outfit.is_stale()

            renpy.hide_screen("wardrobe")
            char_active.wear("all")
            renpy.play('sounds/door2.ogg')

            if wardrobe_music:
                renpy.music.play(last_track)

            DollThread.stop_all()

            enable_game_menu()
            renpy.return_statement()

    jump .after_init

screen wardrobe_menu(xx, yy):
    tag wardrobe
    zorder 24
    style_prefix "wardrobe"

    default icon_bg = Frame(gui.format("interface/frames/{}/iconmed.webp"), 6, 6)
    default icon_frame = Frame(gui.format("interface/frames/{}/iconframe.webp"), 6, 6)
    default panel = gui.format("interface/frames/{}/wardrobe.webp")

    window:
        pos (xx, yy)
        xysize (344, 507)
        #background panel

        use invisible_button()

        # Main Categories
        grid 2 4:
            ypos 108
            xoffset -36
            xspacing 200 + 72
            yspacing 18

            for i, category in enumerate(wardrobe_categories):
                button:
                    focus_mask None
                    xysize (72, 72)
                    background lock_wardrobe_icon(Fixed(icon_bg, Transform(f"interface/wardrobe/icons/categories/{states.active_girl}/{category}.webp", zoom=0.45, anchor=(0.5, 0.5), align=(0.5, 0.5), matrixcolor=(IdentityMatrix() if wardrobe_check_category(category) else SaturationMatrix(0.0))), icon_frame))
                    activate_sound "sounds/scroll.ogg"
                    tooltip category
                    sensitive (not bool(DollThread._count))
                    action Return(["category", category])
                    if current_category == category:
                        xoffset (-18 if (i % 2) == 0 else 18)

        # Outfits and Studio
        hbox:
            $ icon_yoffset = -18

            pos (92, 18)
            spacing 18
            # Outfits Manager
            button:
                focus_mask None
                xysize (72, 72)
                background lock_wardrobe_icon(Fixed(icon_bg, Transform("interface/wardrobe/icons/categories/outfits.webp", zoom=0.45, anchor=(0.5, 0.5), align=(0.5, 0.5)), icon_frame))
                tooltip "Outfits Manager"
                sensitive (not bool(DollThread._count))
                action Return(["category", "outfits"])
                if current_category == "outfits":
                    yoffset icon_yoffset

            # Studio
            if not renpy.android:
                button:
                    focus_mask None
                    xysize (72, 72)
                    background Fixed(icon_bg, Transform("interface/wardrobe/icons/categories/studio.webp", zoom=0.45, anchor=(0.5, 0.5), align=(0.5, 0.5)), icon_frame)
                    tooltip "Photo Studio"
                    action Function(renpy.call_in_new_context, "studio", states.active_girl)

        add panel

        # Character image cut to the size of the wardrobe
        add char_active.image:
            yoffset -6
            corner1 (184, 218)
            corner2 (924, 1200)
            zoom 0.45
            align (0.5, 1.0)

        # Easter Egg (Headpats, boobs, pussy)
        button style "empty" xysize (120, 80) xalign 0.525 ypos 60 action Return(["touch", "head"])
        button style "empty" xysize (120, 60) xalign 0.525 ypos 238 action Return(["touch", "breasts"])
        button style "empty" xysize (120, 60) xalign 0.525 ypos 360 action Return(["touch", "vagina"])

        button:
            focus_mask None
            xysize (72, 72)
            align (0.0, 1.0)
            offset (10, -10)
            background lock_wardrobe_icon(Transform("interface/wardrobe/icons/random.webp", size=(72,72)))
            tooltip "Randomise Outfit"
            sensitive (not DollThread._count)
            action Return("randomise")

        use dropdown_menu(name="Options", pos=(12, 56)):
            textbutton "Music":
                style gui.theme("dropdown")
                tooltip "My immortal."
                selected wardrobe_music
                action Return("music")
            textbutton "Chit-chats":
                style gui.theme("dropdown")
                tooltip "{color=#35aae2}[states.active_girl]{/color} will make comments regarding your poor fashion tastes."
                action ToggleVariable("wardrobe_chitchats", True, False)
            textbutton "Outfits Scheduling":
                style gui.theme("dropdown")
                tooltip "{color=#35aae2}[states.active_girl]{/color} will automatically wear outfits\nbased on set schedule, time of day and weather."
                action [ToggleVariable(f"states.{states.active_girl[:3]}.wardrobe_scheduling", True, False), If((current_category == "outfits" and current_subcategory == "schedule"), Return(["subcategory", "save"]))]
            textbutton "Outfits Autosave":
                style gui.theme("dropdown")
                tooltip "Outfits will be automatically saved upon exit."
                action ToggleVariable("wardrobe_autosave", True, False)
            textbutton "Colour Synchronisation":
                style gui.theme("dropdown")
                tooltip "When changing colours of an item, apply it to all outfits with the same item."
                action ToggleVariable("wardrobe_global_color", True, False)
            textbutton "Colour Randomisation":
                style gui.theme("dropdown")
                tooltip "When randomising outfits, randomise colours as well."
                action ToggleVariable("wardrobe_randomise_color", True, False)
            textbutton "Prompts Suppression":
                style gui.theme("dropdown")
                tooltip "Disables warnings and prompts asking you to confirm certain actions. (Not recommended)"
                action ToggleVariable("wardrobe_suppress_warnings", True, False)

screen wardrobe_menuitem(xx, yy):
    tag wardrobe_menuitem
    zorder 24
    style_prefix "wardrobe"

    default icon_size = (96, 96)
    default icon_frame = Frame(gui.format("interface/frames/{}/iconframe.webp"), 6, 6)
    default icon_transparent = Frame("interface/color_picker/checker.webp", tile=True)
    default panel = gui.format("interface/frames/{}/panel.webp")

    window:
        pos (xx, yy)
        xysize (560, 454)
        background panel

        use invisible_button()

        text "[current_category]" size 22 xalign 0.5 ypos 65

        # Colours
        if current_item and current_item.color:
            hbox:
                spacing 2
                xanchor 1.0
                pos (552, 61)

                # Colour picker
                button:
                    xysize (32, 32)
                    tooltip "Dye clothing"
                    action Return(["setcolor", 0])
                    add "interface/wardrobe/icons/brush.webp":
                        xysize (32, 32)

        # Subcategory icons
        hbox:
            spacing 5
            pos (12, 108)

            for subcategory in category_items.keys():
                $ icon = lock_wardrobe_icon(f"interface/wardrobe/icons/{subcategory}.webp")

                button:
                    focus_mask None
                    xysize (72, 72)
                    background Transform(icon, size=(72, 72), fit="contain", alpha=0.65)
                    selected_background Transform(icon, size=(72, 72), fit="contain", )
                    selected (subcategory == current_subcategory)
                    tooltip subcategory
                    sensitive (not bool(DollThread._count))
                    action Return(["subcategory", subcategory])

        # # Item icons
        # if not menu_items:
        #     text "Nothing here yet" size 24 align (0.5, 0.6)
        # else:
        vpgrid:
            cols 5
            spacing 5
            pos (28, 192)
            xysize (507, 308)
            mousewheel True
            scrollbars "vertical"

            style_prefix gui.theme("wardrobe")

            for item in category_items.get(current_subcategory, []):
                add item.button

screen wardrobe_outfit_menuitem(xx, yy):
    tag wardrobe_menuitem
    zorder 24
    style_prefix "wardrobe"

    default icon_size = (96, 168)
    default icon_frame = Frame(gui.format("interface/frames/{}/iconframe.webp"), 6, 6)
    default panel = gui.format("interface/frames/{}/panel.webp")

    window:
        pos (xx, yy)
        xysize (560, 454)
        background panel

        use invisible_button()

        text "[current_category]" size 22 xalign 0.5 ypos 65

        # Subcategory icons
        hbox:
            spacing 5
            pos (8, 108)

            for subcategory in category_items.keys():
                $ icon = lock_wardrobe_icon(f"interface/wardrobe/icons/{subcategory}.webp")
                $ action = Return(["subcategory", subcategory])

                if subcategory == "schedule" and not get_character_scheduling(states.active_girl):
                    $ icon = gray_tint(icon)
                    $ action = Confirm("Outfit scheduling is currently disabled,\nwould you like to turn it on?", [SetVariable(f"states.{states.active_girl[:3]}.wardrobe_scheduling", True), Return(["subcategory", subcategory])])

                button:
                    focus_mask None
                    xysize (72, 72)
                    background Transform(icon, alpha=0.65, xsize=72, fit="contain")
                    selected_background Transform(icon, xsize=72, fit="contain")
                    selected (subcategory == current_subcategory)
                    sensitive (not bool(DollThread._count))
                    tooltip subcategory
                    action action

        # Outfit icons
        vpgrid:
            cols 5
            spacing 5
            pos (28, 192)
            xysize (507, 308)

            # if renpy.android:
            #     mousewheel "horizontal"
            #     scrollbars "horizontal"
            # else:
            mousewheel True
            scrollbars "vertical"
            style_prefix gui.theme("wardrobe")

            # Add empty slot
            if current_subcategory == "save":
                textbutton "Save":
                    focus_mask None
                    xysize icon_size
                    insensitive_background "#0000001A"
                    idle_background "#00000033"
                    text_align (0.5, 0.5)
                    sensitive (not bool(DollThread._count))
                    action Return(["addoutfit", None])

            if current_subcategory == "import":
                for item in list_outfit_files():
                    add item
            else:

                for item in reversed(category_items.get(current_subcategory, [])):
                    add item.button

screen wardrobe_schedule_menuitem(item):
    tag dropdown
    zorder 24

    default mpos = renpy.get_mouse_pos()

    use invisible_button(action=Return(), alternate=Show("wardrobe_schedule_menuitem", item=item))

    window:
        style "empty"
        pos mpos
        #use invisible_button(action=NullAction(), alternate=Return())

        frame:
            style "empty"
            background "#00000080"
            padding (5, 5, 5, 5)

            vbox:
                spacing 0
                for i in wardrobe_outfit_schedule:
                    $ boolean = "" if item.schedule[i] else "Not "
                    $ caption = f"{boolean}worn during the {i}" if i in ("day", "night") else f"{boolean}worn in {i} weather"
                    textbutton i:
                        style gui.theme("dropdown")
                        tooltip caption
                        action [ToggleDict(item.schedule, i, True, False), item.clear_button_cache, Function(item.build_button, current_subcategory)]

style wardrobe_window is empty

style wardrobe_button is empty:
    foreground None
    hover_foreground "#ffffff80"
    activate_sound "sounds/qubodup-click1.ogg"
    hover_sound "sounds/qubodup-hover1.ogg"

style wardrobe_button_text:
    color "#fff"
    insensitive_color "#808080"
    size 20
    outlines [ (2, "#000", 0, 0) ]

style wardrobe_item_caption:
    color "#fff"
    size 14
    outlines [ (1, "#000", 0, 0) ]

style dark_wardrobe_window is wardrobe_window
style dark_wardrobe_button is wardrobe_button
style darK_wardrobe_button_text is wardrobe_button_text
style dark_wardrobe_item_caption is wardrobe_item_caption
style dark_wardrobe_vscrollbar is dark_vscrollbar

style light_wardrobe_window is wardrobe_window
style light_wardrobe_button is wardrobe_button
style light_wardrobe_button_text is wardrobe_button_text
style light_wardrobe_item_caption is wardrobe_item_caption
style light_wardrobe_vscrollbar is light_vscrollbar