#A gui for custom-install.py
#By LyfeOnEdge
import os, sys, platform, subprocess, threading
import tkinter as tk
import tkinter.filedialog as tkfiledialog

STANDARD_OFFSET = 10 #Offset to place everything
BUTTONSIZE = 30
monospace = ("Monospace",10)
boldmonospace = ("Monospace",10,"bold")

# Custom button
class Button(tk.Label):
	"""Cross-platform button"""
	def __init__(self,frame,callback,**kw):
		self.callback = callback
		self.background = "#aaaaaa"
		self.selected = False
		tk.Label.__init__(self, frame, **kw)
		self.configure(anchor="center")
		self.configure(background=self.background)
		self.configure(highlightthickness=1)
		self.configure(font = monospace)
		self.configure(highlightbackground = "#999999")
		self.bind('<Button-1>', self.on_click)

	# Use callback when our makeshift "button" clicked
	def on_click(self, event=None):
		self.configure(background="#dddddd")
		if not self.selected:
			self.after(100, self.on_click_color_change)
		if self.callback:
			self.callback()

	# Function to set the button's image
	def setimage(self, image):
		self.configure(image=image)

	# Function to set the button's text
	def settext(self, text):
		self.configure(text=text)

	def deselect(self):
		self.selected = False
		self.configure(background=self.background)

	def on_click_color_change(self):
		if not self.selected:
			self.configure(background=self.background)

class PathEntry(tk.Entry):
	"""Tkinter entry widget with a button to set the file path using tkinter's file dialog"""
	def __init__(self, frame, dir = False, filetypes = None, *args, **kw):
		self.dir = dir
		self.filetypes = filetypes
		container = tk.Frame(frame)
		self.button = Button(container, self.set_path, text = "...")
		self.button.place(relheight = 1, relx = 1, x = - BUTTONSIZE, width = BUTTONSIZE)
		tk.Entry.__init__(self, container, *args, **kw)
		self.text_var = tk.StringVar()
		self.configure(textvariable = self.text_var)
		super().place(relwidth = 1, relheight = 1, width = - BUTTONSIZE)
		self.container = container

	def clear(self):
		self.text_var.set("")

	def set(self, string):
		self.text_var.set(string)

	def get_var(self):
		return self.text_var

	def get(self):
		return self.text_var.get()

	def place(self, **kw):
		self.container.place(**kw)

	def set_path(self):
		if not self.dir:
			self.set(tkfiledialog.askopenfilename(filetypes = self.filetypes))
		else:
			self.set(tkfiledialog.askdirectory())

class LabeledPathEntry(PathEntry):
	"""Gives the PathEntry class a label"""
	def __init__(self, frame, text, *args, **kw):
		self.xtainer = tk.Frame(frame)
		label = tk.Label(self.xtainer, text = text)
		label.place(width = label.winfo_reqwidth(), relheight = 1)
		PathEntry.__init__(self, self.xtainer, *args, **kw)		
		PathEntry.place(self, relwidth = 1, relheight = 1, width = - (label.winfo_reqwidth() + 5), x = label.winfo_reqwidth() + 5)

	def place(self, **kw):
		self.xtainer.place(**kw)


class AutoScroll(object):
	def __init__(self, master):
		try:
			vsb = tk.Scrollbar(master, orient='vertical', command=self.yview)
		except:
			pass
		hsb = tk.Scrollbar(master, orient='horizontal', command=self.xview)

		try:
			self.configure(yscrollcommand=self._autoscroll(vsb))
		except:
			pass
		self.configure(xscrollcommand=self._autoscroll(hsb))

		self.grid(column=0, row=0, sticky='nsew')
		try:
			vsb.grid(column=1, row=0, sticky='ns')
		except:
			pass
		hsb.grid(column=0, row=1, sticky='ew')

		master.grid_columnconfigure(0, weight=1)
		master.grid_rowconfigure(0, weight=1)

		methods = tk.Pack.__dict__.keys() | tk.Grid.__dict__.keys() \
			| tk.Place.__dict__.keys()

		for m in methods:
			if m[0] != '_' and m not in ('config', 'configure'):
				setattr(self, m, getattr(master, m))


	@staticmethod
	def _autoscroll(sbar):
		'''Hide and show scrollbar as needed.'''
		def wrapped(first, last):
			first, last = float(first), float(last)
			if first <= 0 and last >= 1:
				sbar.grid_remove()
			else:
				sbar.grid()
			sbar.set(first, last)
		return wrapped

	def __str__(self):
		return str(self.master)


def _create_container(func):
	'''Creates a tk Frame with a given master, and use this new frame to
	place the scrollbars and the widget.'''
	def wrapped(cls, master, **kw):
		container = tk.Frame(master)
		container.bind('<Enter>', lambda e: _bound_to_mousewheel(e, container))
		container.bind(
			'<Leave>', lambda e: _unbound_to_mousewheel(e, container))
		return func(cls, container, **kw)
	return wrapped


def _bound_to_mousewheel(event, widget):
	child = widget.winfo_children()[0]
	if platform.system() == 'Windows' or platform.system() == 'Darwin':
		child.bind_all('<MouseWheel>', lambda e: _on_mousewheel(e, child))
		child.bind_all('<Shift-MouseWheel>',
					   lambda e: _on_shiftmouse(e, child))
	else:
		child.bind_all('<Button-4>', lambda e: _on_mousewheel(e, child))
		child.bind_all('<Button-5>', lambda e: _on_mousewheel(e, child))
		child.bind_all('<Shift-Button-4>', lambda e: _on_shiftmouse(e, child))
		child.bind_all('<Shift-Button-5>', lambda e: _on_shiftmouse(e, child))


def _unbound_to_mousewheel(event, widget):
	if platform.system() == 'Windows' or platform.system() == 'Darwin':
		widget.unbind_all('<MouseWheel>')
		widget.unbind_all('<Shift-MouseWheel>')
	else:
		widget.unbind_all('<Button-4>')
		widget.unbind_all('<Button-5>')
		widget.unbind_all('<Shift-Button-4>')
		widget.unbind_all('<Shift-Button-5>')


def _on_mousewheel(event, widget):
	if platform.system() == 'Windows':
		widget.yview_scroll(-1 * int(event.delta / 120), 'units')
	elif platform.system() == 'Darwin':
		widget.yview_scroll(-1 * int(event.delta), 'units')
	else:
		if event.num == 4:
			widget.yview_scroll(-1, 'units')
		elif event.num == 5:
			widget.yview_scroll(1, 'units')


class ScrolledText(AutoScroll, tk.Text):
	@_create_container
	def __init__(self, master, **kw):
		tk.Text.__init__(self, master, **kw)
		AutoScroll.__init__(self, master)

# from https://stackoverflow.com/questions/3221956/how-do-i-display-tooltips-in-tkinter
class CreateToolTip(object):
    """
    create a tooltip for a given widget
    """
    def __init__(self, widget, text='widget info'):
        self.waittime = 500     #miliseconds
        self.wraplength = 180   #pixels
        self.widget = widget
        self.text = text
        self.widget.bind("<Enter>", self.enter)
        self.widget.bind("<Leave>", self.leave)
        self.widget.bind("<ButtonPress>", self.leave)
        self.id = None
        self.tw = None

    def enter(self, event=None):
        self.schedule()

    def leave(self, event=None):
        self.unschedule()
        self.hidetip()

    def schedule(self):
        self.unschedule()
        self.id = self.widget.after(self.waittime, self.showtip)

    def unschedule(self):
        id = self.id
        self.id = None
        if id:
            self.widget.after_cancel(id)

    def showtip(self, event=None):
        x = y = 0
        x, y, cx, cy = self.widget.bbox("insert")
        x += self.widget.winfo_rootx() + 25
        y += self.widget.winfo_rooty() + 20
        # creates a toplevel window
        self.tw = tk.Toplevel(self.widget)
        # Leaves only the label and removes the app window
        self.tw.wm_overrideredirect(True)
        self.tw.wm_geometry("+%d+%d" % (x, y))
        label = tk.Label(self.tw, text=self.text, justify='left',
                       background="#ffffff", relief='solid', borderwidth=1,
                       wraplength = self.wraplength)
        label.pack(ipadx=1)

    def hidetip(self):
        tw = self.tw
        self.tw= None
        if tw:
            tw.destroy()


class threader_object:
	"""an object to be declared outside of tk root so 
	things can be called asyncronously (you cannot start
	a new thread from within a tkinter callback so you
	must call it from an object that exists outside)"""
	def do_async(self, func, arglist = []):
		threading.Thread(target = func, args = arglist).start()


class gui(tk.Tk):
	def __init__(self, threader):
		self.threader = threader
		tk.Tk.__init__(self)
		self.minsize(300, 400)
		self.title("custom-install gui")
		
		outer_frame = tk.Frame(self)
		outer_frame.place(relwidth = 1, relheight = 1, x = + STANDARD_OFFSET, width = - 2 * STANDARD_OFFSET, y = + STANDARD_OFFSET, height = - 2 * STANDARD_OFFSET)
		
		self.sd_box = LabeledPathEntry(outer_frame, "Path to SD root -", dir = True)
		self.sd_box.place(relwidth = 1, height = 20, x = 0)
		
		self.sed_box = LabeledPathEntry(outer_frame, "Path to movable.sed file -", filetypes = [('sed file', '*.sed')])
		self.sed_box.place(relwidth = 1, height = 20, x = 0, y = 30)
		
		self.boot9_box = LabeledPathEntry(outer_frame, "Path to boot9 file -", filetypes = [('boot9 file', '*.bin')])
		self.boot9_box.place(relwidth = 1, height = 20, x = 0, y = 60)

		#-------------------------------------------------
		cia_container = tk.Frame(outer_frame, borderwidth = 0, highlightthickness = 0)
		cia_container.place(y = 90, relwidth = 1, height = 115)
		
		cia_label = tk.Label(cia_container, text = "cia paths - ")
		cia_label.place(relwidth = 1, height = 20)
		self.cia_box = tk.Listbox(cia_container, highlightthickness = 0)
		self.cia_box.place(relwidth = 1, height = 70, y = 20)
		
		add_cia_button = Button(cia_container, self.add_cia, text = "add cia", font = monospace)
		add_cia_button.place(relx = 0, relwidth = 0.333, height = 20, y = 92, width = - 6)
		
		add_cia_folder_button = Button(cia_container, self.add_cia_folder, text = "add folder", font = monospace)
		add_cia_folder_button.place(relx = 0.333, relwidth = 0.333, height = 20, y = 92, x = + 3, width = - 6)
		
		remove_cia_button = Button(cia_container, self.remove_cia, text = "remove cia", font = monospace)
		remove_cia_button.place(relx = 0.666, relwidth = 0.333, height = 20, y = 92, x = + 6, width = - 6)
		#-------------------------------------------------

		self.skip_contents = tk.IntVar()
		skip_contents_checkbutton = tk.Checkbutton(outer_frame, text="Skip contents? (only add title info)", variable=self.skip_contents)
		skip_contents_checkbutton.place(relwidth = 1, y = 205, height = 20)

		console_label = tk.Label(outer_frame, text = "Console:", background = "black", foreground = "white", font = boldmonospace, borderwidth = 0, highlightthickness = 0)
		console_label.place(relwidth = 1, height = 20, y = 230)
		self.console = ScrolledText(outer_frame, background = "black", foreground = "white", highlightthickness = 0)
		self.console.place(relwidth = 1, relheight = 1, y = 250, height = - 272)
		run_button = Button(outer_frame, self.run, text = "run", font = boldmonospace)
		run_button.place(relwidth = 1, rely = 1, y = - 22)

	def run(self):
		argstring = ""

		self.output_to_console("-----------------------\nStarting...\n")

		boot9 = self.boot9_box.get()
		if not boot9:
			self.output_to_console("Warning - boot9 not selected, if it's not set externally you may run into problems.\n")
		argstring += f"-b {boot9} "
		
		sed = self.sed_box.get()
		if not sed:
			self.output_to_console("Failed to run - No movable.sed selected.\n")
			return
		argstring += f"-m {sed} "

		sd = self.sd_box.get().strip()
		if not sd:
			self.output_to_console("Failed to run - SD path not selected.\n")
			return
		argstring += f"--sd {sd} "

		cias = []
		for i in range(0, self.cia_box.size()):
			cias.append(self.cia_box.get(i).strip())
		for cia in cias:
			argstring += f" {cia}"

		if self.skip_contents.get():
			argstring += "--skip-contents "

		print(f"Running custom-install.py with args {args}\n")

		self.threader.do_async(execute_script, [argstring, self.output_to_console])

	def output_to_console(self, outstring):
		self.console.insert('end', outstring)
		self.console.see('end')

	def add_cia(self):
		cia_to_add = tkfiledialog.askopenfilename(filetypes = [('cia file', '*.cia')])
		if cia_to_add:
			self.cia_box.insert('end', cia_to_add)

	def add_cia_folder(self):
		cia_dir_to_add = tkfiledialog.askdirectory()
		if cia_dir_to_add:
			cias_to_add = [f for f in os.listdir(cia_dir_to_add) if (os.path.isfile(os.path.join(cia_dir_to_add, f)) and f.endswith(".cia"))]
			if cias_to_add:
				for cia_to_add in cias_to_add:
					self.cia_box.insert('end', cia_to_add)

	def remove_cia(self):
		index = self.cia_box.curselection()
		if index:
			self.cia_box.delete(index)
			if self.cia_box.size():
				self.cia_box.select_clear(0, 'end')
				if self.cia_box.size() > 1:
					try:
						self.cia_box.select_set(index)
					except:
						pass
				else:
					self.cia_box.select_set(0)


def execute_script(argstring, printer):
	"""Wrapper function to pipe install script output to a printer"""
	try:
		args = [sys.executable, '-u', os.path.join(os.path.dirname(__file__), "custom-install.py")]
		for arg in argstring.split():
			args.append(arg.strip())
		p = subprocess.Popen(args,
				stdout=subprocess.PIPE, 
				stderr=subprocess.STDOUT, 
				bufsize=1,
			)

		with p.stdout:
			for line in iter(p.stdout.readline, b''):
				printer(line)
		p.wait()
	except Exception as e:
		printer(f"Error while executing script with args - {argstring} | Exception - {e}\n")


t = threader_object()
window = gui(t)
window.mainloop()