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 resource_path(self, relative_path):
        """ Get absolute path to resource, works for dev and for PyInstaller """
        try:
            # PyInstaller creates a temp folder and stores path in _MEIPASS
            base_path = sys._MEIPASS
        except Exception:
            base_path = os.path.abspath(".")
        return os.path.join(base_path, relative_path)
        
    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):
        # This method selects the next image that hasn't been shown yet and adds it to the history
        if self.image_files and len(self.history) < len(self.image_files):
            # Create a set of all images and subtract the set of images already shown
            remaining_images = set(self.image_files) - set(self.history)
            # Randomly choose from remaining images
            next_image = random.choice(list(remaining_images))
            self.history.append(next_image)
            self.history_index += 1
        elif len(self.history) >= len(self.image_files):
            # All images have been shown; reset history to start showing again
            self.history = []
            self.history_index = -1
            # Now call this function again to add the first image after reset
            self.add_image_to_history()

    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 load_image(self, image_path):

    def display_image(self): 
        if self.image_folder != "" and len(self.image_files) > 0:
            if self.update_switch_timestamps():
                # Show the text of the image name instead of loading the actual image
                image_name =  self.history[self.history_index]
                self.canvas.delete("all")  # Clear the canvas
                self.canvas.create_text(
                    self.canvas.winfo_width() // 2, 
                    self.canvas.winfo_height() // 2,
                    text=image_name,
                    fill="white"
                )
                # Schedule the image load with a delay
                if self.timer is not None:
                    self.root.after_cancel(self.timer) # Cancel existing timer to avoid conflicts
                self.timer = self.root.after(500, self.load_image_delayed) # Set a new timer to load the image after 500ms

            else:
                # Load the image normally if not quick-switching
                self.current_image_index = self.history[self.history_index]
                image_path = os.path.join(self.image_folder, self.current_image_index)
                self.path_to_open = image_path
                threading.Thread(target=self.load_image, args=(image_path,)).start()

    def next_image(self, event=None):
        if self.image_folder != "":
            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:
                    # If we still have images to show in the current session, we don't reset the interval
                    pass
            else:
                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()

                # For regular (non-session) mode, simply reset the timer interval to the value set in the timer dialog
                self.timer_interval = self.set_timer_interval

            self.display_image()
        
    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
                self.session_image_count, interval = self.current_session_list[self.session_index]
                self.timer_interval = interval * 1000
            else:
                self.session_image_count += 1
                # The timer interval remains the same since we are still within the same session step
        else:
            # For regular (non-session) mode, simply reset the timer interval to the value set in the timer dialog
            self.timer_interval = self.set_timer_interval





the second image resets the timer to default 15s regardless whether its session mode or not. i want it to respect the session mode. i want it to follow the timer directly when session mode is inactive. while session mode is active i want it to use the session list. and when session mode is on, pressing next and previous it should go through the sessionlist, until it reaches the end and just pause. and when i press next or start again after the pause, it just go through the sessionlist again.

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.