class CustomTimeDialog(simpledialog.Dialog):
    def __init__(self, parent, current_session_timings=None, is_session_mode=False, **kwargs):
        # Only set defaults if current_session_timings is None or empty
        if not current_session_timings:  # This checks both None and empty list [] conditions
            # Set default initial list here (only if there are no existing session timings)
            current_session_timings = ['2 pics for 2s', '1 pics for 1s', '3 pics for 1s']
        self.current_session_timings = current_session_timings
        self.is_session_mode = is_session_mode
        super().__init__(parent, **kwargs)
        
    def body(self, master):
        self.timebutton_style = {"font": ("consolas", 11), 
        "fg": "white", "bg": "#3c3c3c", "relief": "flat"}
        self.title('Custom Time')
        self.time_background = "#242424"
        self.time_fg="white"

        master.configure(bg=self.time_background)
        self.configure(bg=self.time_background)

        self.ico = self.resource_path_timer("icon.ico")
        self.iconbitmap(self.ico)

        #timebox--------------------------------------------------
        ctime_frame = tk.Frame(master, bg=self.time_background)
        ctime_frame.grid(row=1, column=1)
        self.timebox = tk.Listbox(ctime_frame, height=6, width=15, 
                        font=self.timebutton_style["font"], 
                        bg=self.timebutton_style["bg"], fg="#dddddd", 
                        selectbackground="#222222")

        for time_string in ['15s', '30s', '45s', '1m', '5m', '10m']:
            self.timebox.insert(tk.END, time_string)
        self.timebox.grid(row=1, column=1)
        self.timebox.bind('<<ListboxSelect>>', self.set_spinboxes_from_selection)

        #minutebox-----------------------------------------------
        # Main frame to contain the minutes and seconds frames
        time_frame = tk.Frame(ctime_frame, bg=self.time_background)
        time_frame.grid(row=2, column=1, pady=5)# side=tk.TOP, fill=tk.X, padx=5, pady=5)

        # Create a frame for the minutes spinbox and label
        minutes_frame = tk.Frame(time_frame, bg=self.time_background)
        minutes_frame.pack(side=tk.LEFT, fill=tk.X)#, padx=5)

        tk.Label(minutes_frame, text="Minutes:", 
                bg=self.time_background, fg=self.time_fg, 
                font=self.timebutton_style["font"]).pack(side=tk.TOP)
        self.spin_minutes = tk.Spinbox(minutes_frame, from_=0, to=59, width=5, font=self.timebutton_style["font"])
        self.spin_minutes.pack(side=tk.TOP)

        # Create a frame for the seconds spinbox and label
        seconds_frame = tk.Frame(time_frame, bg=self.time_background)
        seconds_frame.pack(side=tk.LEFT, fill=tk.X, padx=5)

        tk.Label(seconds_frame, text="Seconds:", bg=self.time_background, 
            fg=self.time_fg, font=self.timebutton_style["font"]).pack(side=tk.TOP)
        self.spin_seconds = tk.Spinbox(seconds_frame, from_=0, to=59, value=15, 
            width=5, font=self.timebutton_style["font"], wrap=True)
        self.spin_seconds.pack(side=tk.TOP)

        #togsessbox-------------------------------------------------
        session = tk.LabelFrame(master, fg=self.timebutton_style["fg"], bg=self.time_background, relief=tk.FLAT)#, text="Sessions"
        session.grid(row=1, column=2)

        #togsessbox = tk.Frame(master, bg=self.time_background)
        togsess_frame = tk.Frame(session, bg=self.time_background)
        togsess_frame.grid (row=3,column=1, pady=5)
        self.togsess_mode = tk.BooleanVar(value=False)

        #self.togsess_frame = tk.Checkbutton(togsess_frame, bg=self.time_background)
        self.togsess_checkbox = tk.Checkbutton(togsess_frame, text="Session", 
        variable=self.togsess_mode, command=self.toggle_togsess)
        self.togsess_checkbox.configure(**self.timebutton_style, bd=0)
        self.togsess_checkbox.grid(row=1, column=1, sticky=tk.E, ipadx=12)

        self.img_togsess = tk.Spinbox(togsess_frame, width=3, from_=0, to=100, 
        font=self.timebutton_style["font"], wrap=True, x=500, value=5, state = 'disabled')
        self.img_togsess.grid(row=1, column=2)

        #sessionsbox-----------------------------------------------------------
        self.sessionlist = []
        self.sessionString = tk.StringVar(value=self.sessionlist)
        self.sessionbox = tk.Listbox(session, height=6, width=18, 
            font=self.timebutton_style["font"], bg=self.timebutton_style["bg"], 
            listvariable=self.sessionString, borderwidth=0, state = 'disabled', 
            fg="#dddddd", selectbackground="#222222")#, fg=self.timebutton_style["fg"])       

        self.sessionbox.grid(row=1, column=1)

        #session buttons frame------------------------------------------------------------------
        sessionbuttons = tk.Frame(session, bg=self.time_background)
        sessionbuttons.grid(row=2, column=1)
        self.add_button = tk.Button(sessionbuttons, text="+", width=3, 
            command=self.add_session, default=tk.ACTIVE, state="disabled")
        self.add_button.config(**self.timebutton_style)
        self.add_button.grid(row=1, column=1)
        self.del_button = tk.Button(sessionbuttons, text="-", width=3, 
            command=self.remove_session, default=tk.ACTIVE, state="disabled")
        self.del_button.config(**self.timebutton_style)
        self.del_button.grid(row=1, column=2, padx=(0,10))
        self.up_button = tk.Button(sessionbuttons, text="Ʌ", width=3, 
            command=lambda: self.move(-1), default=tk.ACTIVE, state="disabled")
        self.up_button.config(**self.timebutton_style)
        self.up_button.grid(row=1, column=3)
        self.down_button = tk.Button(sessionbuttons, text="V", width=3, 
            command=lambda: self.move(1), default=tk.ACTIVE, state="disabled")
        self.down_button.config(**self.timebutton_style)
        self.down_button.grid(row=1, column=4)
        
        self.togsess_mode.set(self.is_session_mode)
        if self.is_session_mode:
            self.toggle_togsess()  # Initialize the state of session elements based on current setting

        # Update the Listbox content with the current session timings:
        self.sessionString.set(self.current_session_timings)
        self.sessionlist = list(self.current_session_timings)

        return self.spin_seconds  # initial focus

    def add_session(self):
        try:
            img_togsess_value = int(self.img_togsess.get() or 0)
        except ValueError:
            img_togsess_value = 0

        try:
            minutes_input = int(self.spin_minutes.get() or 0)
        except ValueError:
            minutes_input = 0

        try:
            seconds_input = int(self.spin_seconds.get() or 0)
        except ValueError:
            seconds_input = 0

        # Convert total seconds to minutes and seconds
        minutes, seconds = divmod(minutes_input * 60 + seconds_input, 60)

        # Format the session string based on the minutes and seconds
        if minutes > 0 and seconds == 0:
            session_str = f"{img_togsess_value} pics for {minutes}m"
        elif minutes == 0 and seconds > 0:
            session_str = f"{img_togsess_value} pics for {seconds}s"
        elif minutes > 0 and seconds > 0:
            session_str = f"{img_togsess_value} pics for {minutes}m {seconds}s"
        else:
            # If both minutes and seconds are missing or 0, use 0s in the string
            session_str = f"{img_togsess_value} pics for 0s"

        # Append session string to the session list
        self.sessionlist.append(session_str)

        # Update the session string representation
        self.sessionString.set(self.sessionlist)

        # Select the newly added session in the session box
        self.sessionbox.selection_set(len(self.sessionlist) - 1)


    def remove_session(self):
        selected_index = self.sessionbox.curselection()
        if not selected_index:
            return

        selected_index = selected_index[0]
        self.sessionlist.pop(selected_index)
        self.sessionString.set(self.sessionlist)

        if selected_index < len(self.sessionlist):
            self.sessionbox.selection_set(selected_index)
        elif len(self.sessionlist) > 0:
            self.sessionbox.selection_set(len(self.sessionlist) - 1)

    def move(self, num):
        #num is -1 for up and 1 for down
        self.idxs = self.sessionbox.curselection()
        if not self.idxs:
            return
        for pos in self.idxs:
            text=self.sessionbox.get(pos) #gets text
            self.sessionbox.delete(pos) #removes text from list box
            self.sessionlist.pop(pos)  #removes text from list
            if pos==len(self.sessionlist) and num==1: pos=-1; #sets at beginning if at bottom and going down
            if pos==0 and num==-1: pos=len(self.sessionlist)+1; #sets at end if at top and going up
            self.sessionbox.insert(pos+num, text) #inserts into list box
            self.sessionlist.insert(pos+num, text) #inserts into list
            self.sessionbox.selection_set(pos+num)

    def toggle_togsess(self):
        if self.togsess_mode.get():
            self.togsess_checkbox.configure(fg="#2c2c2c", bg="#b8b8b8")
            self.img_togsess.config(state = 'normal')
            self.sessionbox.config (state = 'normal')
            self.add_button.config (state = 'normal')
            self.del_button.config (state = 'normal')
            self.up_button.config  (state = 'normal')
            self.down_button.config(state = 'normal')
        else:
            self.togsess_checkbox.configure(**self.timebutton_style)
            self.img_togsess.config(state = 'disabled')
            self.sessionbox.config (state = 'disabled')
            self.add_button.config (state = 'disabled')
            self.del_button.config (state = 'disabled')
            self.up_button.config  (state = 'disabled')
            self.down_button.config(state = 'disabled')
            

    def set_spinboxes_from_selection(self, event=None):
        index = self.timebox.curselection()
        if not index:
            return
        time_string = self.timebox.get(index)
        if 'm' in time_string:
            minutes = int(time_string.replace('m', ''))
            seconds = 0
        elif 's' in time_string:
            minutes = 0
            seconds = int(time_string.replace('s', ''))
        else:
            # Handle a possible unknown format
            self.bell()  # ring the bell to signal an error
            return

        self.spin_minutes.delete(0, tk.END)
        self.spin_minutes.insert(0, minutes)
        self.spin_seconds.delete(0, tk.END)
        self.spin_seconds.insert(0, seconds)
        
    def buttonbox(self):
        box = tk.Frame(self, bg=self.time_background)
        self.ok_button = tk.Button(box, text="Apply", width=16, command=self.ok, default=tk.ACTIVE)
        self.ok_button.config(**self.timebutton_style)
        self.ok_button.pack(side=tk.TOP, ipadx=5, pady=5)
        box.pack()

    def apply(self):
        if self.togsess_mode.get():
            # In session mode, store the list of session strings directly
            self.result = self.sessionlist  # Use the list directly instead of self.sessionString.get()
        else:
            # In standard mode, parse and combine minutes and seconds to a single interval in seconds
            try:
                minutes = int(self.spin_minutes.get())
                seconds = int(self.spin_seconds.get())
                self.result = minutes * 60 + seconds  # Total time in seconds
            except ValueError:
                # Fall back to a default interval as needed
                self.result = 1  # Default to 1 second

    def validate(self):
        try:
            minutes = int(self.spin_minutes.get())
            seconds = int(self.spin_seconds.get())
            return True
        except ValueError:
            self.bell()
            return False

class ImageViewer:
    def __init__(self, root):
        self.SUPPORTED_EXTENSIONS = (".png", ".jpg", ".jpeg", ".gif", ".bmp", ".JPG", ".JPEG", ".BMP", ".GIF", ".webp", ".WEBP")
        self.button_style = {"font": ("consolas", 11), "fg": "white", "bg": "#3c3c3c", "relief": "flat"}
        self.button_red = {"font": ("consolas", 11), "fg": "white", "bg": "green", "relief": "flat"}
        self.button_style_disabled = {"font": ("consolas", 11), "fg": "#505050", "bg": "#909090", "relief": "flat"}
        self.timer_style = {"font": ("consolas", 22), "fg": "white", "bg": "#3c3c3c", "relief": "flat"}
        self.tooltip_color = {"fg": "#ffffff", "bg": "#1c1c1c"}
        self.bgcolor = "#242424"
        self.button_width = 3
        #self.image_loading_queue = Queue(maxsize=5)
        self.switch_timestamps = []
        
        self.root = root
        # Initialize the session timings one time
        if not hasattr(self, 'current_session_timings'):  # Check if current_session_timings has not been set
            self.current_session_timings = []  # Empty list
            self.is_session_mode = False
            
        self.root.geometry("800x600")  # Initial window size
        self.root.title("IMG Viewer")
        self.root.configure(bg=self.bgcolor)  # Set window background color
        self.root.attributes("-topmost", False)  # Make the window stay on top
        
        self.image_folder = ""
        self.selected_folder = "none"
        self.image_files = []
        self.current_image_index = 0
        self.history = []
        self.history_index = -1
        self.total_images = 0
        self.togsess_counter = 0
        self.togsess_mode = tk.BooleanVar(value=False)
        self.session_active = False
        self.session_index = 0
        self.session_image_count = 0
        self.current_session_timings = []
        self.is_session_mode = False
        
        self.main_frame = tk.Frame(self.root, bg=self.bgcolor)
        self.main_frame.pack()
        self.root.lift()
        
        self.select_folder_button = tk.Button(self.main_frame, text="Select Folder", command=self.select_folder)
        self.select_folder_button.configure(**self.button_red)
        self.select_folder_button.pack(side=tk.LEFT, padx=5, pady=10)
        ToolTip(self.select_folder_button, msg="Pick a folder", follow=True, 
        **self.tooltip_color)
        
        self.set_timer_button = tk.Button(self.main_frame, text="Timer", command=self.set_timer_interval)
        self.set_timer_button.configure(**self.button_style)
        self.set_timer_button.pack(side=tk.LEFT, padx=5, pady=10)
        ToolTip(self.set_timer_button, msg="Set timer interval", follow=True, 
        **self.tooltip_color)
        
        self.start_button = tk.Button(self.main_frame, text="Start", command=self.start_pause_slideshow)
        self.start_button.configure(**self.button_style_disabled)
        self.start_button.pack(side=tk.LEFT, padx=5, pady=10)
        ToolTip(self.start_button, msg="Start or pause timer", follow=True, 
        **self.tooltip_color)

        
		#image canvas
        self.canvas = tk.Canvas(self.root)
        self.is_mirrored = False
        self.is_greyscale = False
        self.is_paused = True
        self.rotated = 0
        self.vol = True
        self.beep1 = self.resource_path("beep1.wav")
        self.beep2 = self.resource_path("beep2.wav")
        self.ico = self.resource_path("icon.ico")
        self.root.iconbitmap(self.ico)
        
        self.grid_type="d"
        
        self.timer_label = tk.Label(self.root, text="15", anchor="ne") 
        self.timer_label.configure(**self.timer_style)
        self.timer_label.place(relx=1, anchor="ne", x=-0, y=0)

        self.timer_interval = 15000  # Default time interval in milliseconds (15 seconds)
        self.set_timer_interval = 15000  # Store the set timer interval
        self.timer = None  # Timer ID
		
        self.window_size = (self.root.winfo_width(), self.root.winfo_height())
        self.resize_timer = None

        self.root.bind("<Right>", self.next_image)
        self.root.bind("<Left>", self.previous_image)
        self.root.bind("<space>", self.start_pause_slideshow)
        self.root.bind("<Configure>", self.update_image_size)

    def set_timer_interval(self):
        if not hasattr(self, 'current_session_timings'):  # Make sure the properties exist
            self.current_session_timings = []
            self.is_session_mode = False

        # Pass the current session settings to the dialog
        dialog = CustomTimeDialog(self.root, self.current_session_timings, self.is_session_mode)
        if dialog.result is not None:
            self.is_session_mode = dialog.togsess_mode.get()  # Store the new session mode
            if self.is_session_mode:
                self.current_session_timings = dialog.result  # Store the session settings
                # Session mode is active, dialog.result contains the list of session strings
                self.process_session(dialog.result)
                # Set the interval to the first session's time
                self.timer_interval = self.current_session_list[0][1] * 1000
            else:
                # Session mode is inactive, dialog.result should be a numerical value 
                interval = dialog.result
                if interval < 1:  # Check if interval is less than 1 second
                    interval = 1
                self.timer_interval = interval * 1000  # Convert to milliseconds

        self.root.lift()  # Bring the main window to the top
        self.root.focus_force()  # Give focus to the main window
        
        minutes = self.timer_interval // 60000
        seconds = (self.timer_interval % 60000) // 1000
        
        if self.timer_interval <=59000:
            self.timer_label.config(text=f"{seconds}")
        else :
            self.timer_label.config(text=f"{minutes:d}:{seconds:02d}")


    def process_session(self, session_list):
        self.current_session_list = []
        for session_str in session_list:
            try:
                num_pics, time_str = session_str.split(' pics for ')
                minutes, seconds = self.parse_time(time_str)
                self.current_session_list.append((int(num_pics), minutes * 60 + seconds))
            except ValueError as e:
                # Handle the error appropriately, e.g., by logging or messaging the user
                pass  # Or whatever error handling you choose

    def parse_time(self, time_str):
        splits = time_str.split('m')
        if len(splits) > 1:
            minutes = int(splits[0])
            seconds = int(splits[1].replace('s', ''))
        else:
            minutes = 0
            seconds = int(time_str.replace('s', ''))
        return minutes, seconds

    def start_pause_slideshow(self, event=None):
        if self.image_folder == "":
            messagebox.showinfo("You haven't picked a folder", "Please select an image folder first.")
        else:
            if self.timer is None:  # Check if timer is not running
                self.display_image()
                self.start_button.config(text="Pause", **self.button_style)
                self.timer_label.configure(**self.timer_style)
                self.is_paused = False  # Set paused flag to False
                self.start_timer()
            else:
                if self.is_paused:  # Check if the slideshow is paused
                    self.start_button.config(text="Pause", **self.button_style)
                    self.timer_label.configure(**self.timer_style)
                    self.is_paused = False  # Set paused flag to False
                    self.start_timer()
                else:
                    self.pause_timer()
                    self.start_button.config(text="Start", **self.button_red)
                    self.timer_label.configure(bg="green")
                    self.is_paused = True  # Set paused flag to True
    
    def pause_timer(self):
        if self.timer is not None:
            self.root.after_cancel(self.timer)
            self.timer = None
        if self.session_active:
            self.session_index = 0
            self.session_image_count = self.current_session_list[0][0]
            self.timer_interval = self.current_session_list[0][1] * 1000
    def start_timer(self):
        if self.image_folder != "" and not self.is_paused:
            self.update_timer()
            self.timer = self.root.after(1000, self.start_timer)


    def update_timer(self):
        # Calculate minutes and seconds left
        minutes = self.timer_interval // 60000
        seconds = (self.timer_interval % 60000) // 1000

        if self.timer_interval <=59000:
            self.timer_label.config(text=f"{seconds}")
        else :
            self.timer_label.config(text=f"{minutes:d}:{seconds:02d}")
        
        if self.vol:
            if self.timer_interval == 3000:
                wave_obj = sa.WaveObject.from_wave_file(self.beep1)
                play_obj = wave_obj.play()
                play_obj.wait_done()
            if self.timer_interval == 2000:
                wave_obj = sa.WaveObject.from_wave_file(self.beep1)
                play_obj = wave_obj.play()
                play_obj.wait_done()
            if self.timer_interval == 1000:
                wave_obj = sa.WaveObject.from_wave_file(self.beep1)
                play_obj = wave_obj.play()
                play_obj.wait_done()
            if self.timer_interval == 0:
                wave_obj = sa.WaveObject.from_wave_file(self.beep2)
                play_obj = wave_obj.play()
                play_obj.wait_done()

        self.timer_interval -= 1000
            
        if self.timer_interval < 0:
            self.timer_interval = self.set_timer_interval  # Use the stored set timer interval
            self.next_image()
 
    def next_image(self, event=None):
        if self.image_folder != "":
            if len(self.image_files) == len(self.history):
                self.history_index = (self.history_index + 1) % len(self.image_files)
            else:
                self.add_image_to_history()
            self.display_image()
                # Reset the timer interval to the stored set timer interval
        self.timer_interval = self.set_timer_interval
       
        if self.session_active:
            self.session_image_count -= 1
            if self.session_image_count <= 0:
                self.session_index = (self.session_index + 1) % len(self.current_session_list)
                self.session_image_count, interval = self.current_session_list[self.session_index]
                self.timer_interval = interval * 1000  # Setting the new interval from session
            else:
                self.timer_interval = self.set_timer_interval
        else:
            self.timer_interval = self.set_timer_interval
        
    def previous_image(self, event=None):
        if self.image_folder != "" and self.history_index > 0:
            self.history_index -= 1
            self.display_image()

        # When session is active, control the flow based on session settings
        if self.session_active:
            current_count, _ = self.current_session_list[self.session_index]
            # Move to the previous session step, if it's the first image in the current session step
            if self.session_image_count == current_count:
                if self.session_index > 0:
                    self.session_index -= 1
                else:
                    self.session_index = len(self.current_session_list) - 1
                _, interval = self.current_session_list[self.session_index]
                self.session_image_count = self.current_session_list[self.session_index][0]
                self.timer_interval = interval * 1000
            else:
                self.session_image_count += 1
                _, interval = self.current_session_list[self.session_index]
                self.timer_interval = interval * 1000
        else:
            # For regular (non-session) mode, simply reset the timer interval
            self.timer_interval = self.set_timer_interval



when i press next, the timer sets to default 15s. after i set the timer and from the session, it sets to 15s for the second image. i think the timer update code is broken.

when there's something to be changed, give the new codeblock and show me precisely where i can put the codeblock. include the line before and after the new block so i know where to put it on the old code.if something needs to be added, tell me concisely.