class CustomTimeDialog(simpledialog.Dialog):
    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_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 = ['5 pics for 30s', '5 pics for 1m', '5 pics for 5m']
        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")
        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)
        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
        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.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 select_folder(self):
        self.selected_folder = filedialog.askdirectory(initialdir=self.image_folder)
        if not self.selected_folder or self.selected_folder == self.image_folder:
            return
        self.image_folder = self.selected_folder
        if self.image_folder:
            image_files = os.listdir(self.image_folder) # Get all files in the selected folder
            self.image_files = [file for file in image_files if file.endswith(self.SUPPORTED_EXTENSIONS)] 
            self.history = []
            self.history_index = -1
            self.rotated = 0
            self.togsess_counter = 0
            self.total_images = len(self.image_files)
            if self.image_files:
                self.add_image_to_history()
                self.current_image_index = 0
                self.canvas.pack(fill=tk.BOTH, expand=True)
                self.select_folder_button.pack(side=tk.LEFT, padx=5, pady=5)
                self.root.title(f"IMGing in {self.image_folder} found {self.total_images} images")
                self.canvas.config(bg=self.bgcolor, highlightthickness=0)
                self.display_image()   
                self.start_button.config(**self.button_red)
                self.openimgdir.configure(**self.button_style)
                self.mirror_button.configure(**self.button_style)
                self.greyscale_button.configure(**self.button_style)
                self.rotate_button.configure(**self.button_style)
                self.grid_button.configure(**self.button_style)
                self.select_folder_button.configure(**self.button_style)
            else:
                messagebox.showinfo("No Image Files", "The selected folder does not contain any image files.")
                self.image_folder = ""
                self.root.title("IMG")

    def add_image_to_history(self):
        #code
    def set_timer_interval(self):
        
        dialog = CustomTimeDialog(self.root)
        if dialog.result is not None:
            self.session_active = dialog.togsess_mode.get()  # Ensure you're accessing the toggled state from the dialog

            if self.session_active:
                # 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 load_image_delayed(self):
        # This method will be called after the 500ms delay if no keypress happens
        if self.timer is not None:
            self.root.after_cancel(self.timer)  # Cancel the existing timer
        self.timer = None  # Clear the timer ID
        # Load the current image from history without changing to a new random image
        image_path = os.path.join(self.image_folder, self.history[self.history_index])
        threading.Thread(target=self.load_image, args=(image_path,)).start()
        if not self.is_paused:
            self.timer = self.set_timer_interval
            self.root.after(500, self.start_timer)

    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


i want when i activate session mode and set the timer to use the session, and i open the timer again, i want it to save or acknowledge the previous setting in the session list and session checkbox instead of resetting the timer on opening the timer window.
when there's something to be changed, give the new codeblock and show me precisely where i can put the codeblock. if something needs to be added, tell me concisely.