import sqlite3
import time
import threading
import tkinter
from turtle import left, width
import User
import sys
import tkinter as tk
from direct import task
from tkinter import Scale, StringVar
from random import random

#TODO Klassen erstellten

def button_event_close():
	print("Programm wird geschlossen")
	
	return 0;

def guithread():
	
	window_size_x = 1024
	window_size_y = 786
	
	label_logged_in = tk.Label
	label_highscore = tk.Label
	label_lastlogin = tk.Label

	
	#Hauptfenster-Block   
	window1 = tk.Tk() #Instanzierung von Fensterelement
	window1.wm_title("Snake v1.0")
	window1.geometry("1024x768")
	window1.attributes("-topmost", True)


	print("Erstelle User-Klassen Objekt")
	us = User.User()
	
	#Mit der Parameterübergabe der Klasseninstantz Tk, kann auch in einer Methode oder Funktion die Instantz direkt manipuliert werden!
	def mainwindow_test(mainwindow : tk.Tk):
		mainwindow.quit()
		pass

	def close_mainwindow():
		print("Programm wird geschlossen!")
		window1.quit()
			
	def read_user(username, schaltf2:tk.Label, label_user_exists:tk.Label, all_listed_radiob:list): #Eingabeprüfung, bei Exception bei leerem String oder Eingabefeld
		unametemp = username #eingabefeld_wert.get()
		if(len(unametemp) != 0):       
			print("Lese Nutzereingabe: ", unametemp, "\n")
			if(us.select(unametemp) == True):
				welcome_msg = "Willkommen, " + us.getusername()
				highscore_msg = "Dein letzter Highscore lag bei: " + str(us.gethighscore()) + " Punkten"
				lastlogin_msg = "Du warst das letzte Mal am: " + us.getlastlogin() + " am Spielen"
				label_logged_in = tk.Label(window1, text=welcome_msg)
				label_highscore = tk.Label(window1, text=highscore_msg)
				label_lastlogin = tk.Label(window1, text=lastlogin_msg)
				label_logged_in.place(x=180, y=50)
				label_highscore.place(x=180, y=80)
				label_lastlogin.place(x=180, y=110)
				label_user_exists.destroy()
				schaltf2.destroy()
				
				#Zerstört alle gezeichneten Insantzen von Radiobuttons
				for radiobutton in all_listed_radiob:
					radiobutton.destroy()
			return
		else:
			print("Bitte etwas eingeben... Das Feld war leer!") 
			return
		
	def input_new_user(*events):
		
		#Eingabefenster-Block
		subwindow1 = tk.Toplevel(window1)
		subwindow1.wm_title("Eingabe")
		subwindow1.geometry("400x200")
		subwindow1.resizable(0,0) #Blockiert ein Skalieren des Fensters
		window1.attributes("-topmost", False)
		subwindow1.attributes("-topmost", True)
		subwindow1.lift() #Hebt das Child-Fenster zumsammen mit attributes in den Vordergrund


		eingabewert = StringVar(subwindow1)
		def check_input():
			if(len(eingabewert.get()) <= 0):
				print("Es wurde keine Eingabe gemacht!")
			else:
				print(eingabewert.get())
				us.createuser(eingabewert.get())
				subwindow1.destroy()
				build_mainwindow(window1)
			return
		
		textlabel = tk.Label(subwindow1, text="Bitte gib deinen Benutzernamen ein: ")
		label_new_user = tk.Entry(subwindow1, width=40, textvariable=eingabewert)
		button_ok = tk.Button(subwindow1, text="Erstellen", height=1, width=10, command=check_input)
		button_abort = tk.Button(subwindow1, text="Abbrechen", command=subwindow1.destroy)
		
		textlabel.place(x=5, y=5)
		label_new_user.place(x=6, y=25)
		button_ok.place(x=5, y=150)
		button_abort.place(x=140, y=150)
		#label_new_user.place(x=window_size_x*0.25, y=window_size_y*0.6)

	def build_mainwindow(window1 : tk.Tk):
		#Programmüberschrift
		label1 = tk.Label(window1, text="Snake v1.0 written by CB") #Fenster Funktion für Textausgabe
		label1.grid(row=0, column=0)
		#Schaltflächen und Buttons
		schaltf1 = tk.Button(window1, text="Fenster schließen", command=close_mainwindow)
		schaltf1.place(x=5, y=window_size_y-50)

		aktuell_ausgewaehlt =""
		
		
		
		if(us.checkuserdb() == False):
			#Anmeldedialog
			print("Noch kein Nutzer angelegt!")
			#messagebox.Message(master=None, message="Es wurde noch kein Spieler angelegt!", type=messagebox.OK, icon=messagebox.WARNING).show()
			input_new_user()
	
		elif(us.checkuserdb() == True):
			print("Nutzer bereits vorhanden, wähle einen aus!")
			#us.listallusers()

			users = us.listallusers()
			ausgewaehlt = tk.StringVar()

			ausgewaehlt.set(0)
			def value_select():
				aktuell_ausgewaehlt = str(ausgewaehlt.get())
				print(aktuell_ausgewaehlt)
				return 0
			
			print (aktuell_ausgewaehlt)
	
			all_listed_radiob = list()

			i = 0 
			for einzelwert in users:
				radiob = tk.Radiobutton(window1, text=einzelwert, value=einzelwert, variable=ausgewaehlt, command=value_select) 
				all_listed_radiob.append(radiob)
				print (users)
				radiob.place(x=5, y=150+i)
				i+=30
		 
			print("Alle Radiobuttons gesetzt!")  
		
			def login_user():
				print("Melde ausgewählten Nutzer an!\n")
				read_user(ausgewaehlt.get(), schaltf2, label_user_exists, all_listed_radiob)
				return 0

			label_user_exists = tk.Label(window1, text="Wähle deinen Spieler aus: ")
			label_user_exists.place(x=2, y=30)
			#eingabefeld_wert=tk.StringVar()
		
			#eingabefeld=tk.Entry(window1, textvariable=eingabefeld_wert)
			#eingabefeld.place(x=2, y=80)
			schaltf2 = tk.Button(window1, text="Auswählen", command=login_user)
			schaltf2.place(x=150, y=75)

	build_mainwindow(window1)

	#Nützliches Feature um zeitgesteuerte Events in Mainloop ausführen zu können
	def message():
		print('Keep yourself hyderated.')
		window1.after(2000, message)

	#window1.after(2000, message)
	window1.mainloop() #Hauptschleife für gezeichnetes Fenster
	us.__del__() #Stellt sicher, dass User-Klassenobjekt im korrekten Thread beendet wird
	return 0;



class woscht(User.User):
	def __init__(self) -> None:
		UserInstanz = User
		print("Unterklasser der Userklasse erstellt!\n")
		print("So funktioniert die Klassenvererbung in Python...")
		print("Dies ermöglicht eine modulare Aufbauweise ohne sich ständig bei kleineren Abweichung wiederholen zu müssen ober ganze Abschnitte zu kopieren und einzufügen\n")
		
	def Testfunkiton(self):
		print("Das ist eine Funktion, welche ausgeführt wird in einer Kindklasse. Sie existiert nicht in der Elternklasse!\n")
		pass
	def Testfunktion2(self):
		print("Weitere Funktion, welche bei initialisieren der Klasse aufgerufen wird.\n")
	pass
	
class woscht2(woscht):
	def __init__(self) -> None:	
		woscht().Testfunktion2()
		print("Unterklasse der Woschtklasse\n")
		print("Die stellt eine Vererbung auf eine Vererbung dar. Hier können weitere Ergänzungen vorgenommen werden\n")
	pass

#Eine Schleife, welche unter Zuhilfenahme einer Rekursion entsteht.
def recursive(zahl):
	if(zahl==100):
		print("Vorgang abgeschlossen!")
		return
	elif(zahl <= 100):
		zahl += 1
		time.sleep(0.001)
		print(zahl, end="\r")
		return recursive(zahl)
	else:
		print("Ergeniss konnte nicht erreicht werden!")
		return

	
def main():
	#t = threading.Thread(target=guithread ,args=())
	#t.start()
	#recursive(0)
	#while(True):
	#	pass

	"""
	test = woscht()
	test.getusername()
	
	test2 = woscht2()
	test2.Testfunkiton()
	
	testtu = list()

	#Mit dieser Funktion können mehrer Instanzen einer KLasse erstellt werden und im späteren Verlauf über den Listenindex bearbeitet werden.
	for i in range(5):
		testtu.append(woscht2())

	print("Es wurden folgenden Klassen erstellt: ")
	print (len(testtu))
	

	for i in testtu:
		print(i)
	"""
	
	
#    FH = open("user.txt", "w")
#    FH.write(us.getusername())
#    FH.close()
	time.sleep(1)

	return 0

if __name__ == "__main__":
	main()
	
from math import pi, sin, cos

from direct.showbase.ShowBase import ShowBase
from direct.task import Task
from direct.actor.Actor import Actor
from direct.interval.IntervalGlobal import Sequence
from panda3d.core import Point3
from panda3d.core import WindowProperties
from panda3d.core import Loader



#class Game(ShowBase):
#    def __init__(self):
#        ShowBase.__init__(self)
#        properties = WindowProperties()
#        properties.setSize(1024, 768)
#        properties.setTitle("Snake v1 written by CB")
#        properties.setUndecorated(False)
#        self.win.requestProperties(properties)
		
#        self.scene = self.loader.loadModel("models/environment")
#        self.scene.reparentTo(self.render)
#        self.pandaActor = Actor("models/panda-model",
#                                {"walk": "models/panda-walk4"})
#        self.pandaActor.reparentTo(self.render)


		
#game = Game()
#game.run()

from direct.showbase.ShowBase import ShowBase #Grundmodul zum Starten eines Fenster mit Grundszene
from direct.gui.OnscreenText import OnscreenText #Ermöglicht die direkte Einblendung von Texten
from direct.gui.DirectGui import * #Ermöglicht das Einblenden von Menüs und deren Manipulation
from panda3d.core import TextNode #Texte
from direct.task import Task

from panda3d.core import loadPrcFile #Ermöglicht das Laden eigener Konfigurationsdatein zur Panda3D API
loadPrcFile("conf/conf.prc") #Pfadangabe zum .prc File


class User_login:
	__username = str()
	__us = User.User
	__btn = DirectButton
	def __init__(self, username:str(), us:User.User, btn:DirectButton) -> None:
		print("Loginklasse erstellt")
		self.__btn = btn
		self.__us=us
		self.__username=username
		
	def user_select(self):
		print("Wähle Spieler aus: "+self.__username)
		if(self.__us.select(self.__username) == True):
			print("Spieler " + self.__us.getusername() + " wurde angelegt")
			print("Dein letzter Highscore: " + str(self.__us.gethighscore()))
			print("Dein letzter Login: " + self.__us.getlastlogin())
			
			print(self.__btn)
			self.__btn.destroy()
			#self.__btn.clearText(self.__btn)
	def setButtonObject(self, btn:DirectButton):
		self.__btn = btn
		print(self.__btn)

class MyApp(ShowBase):
	
	us = User.User

	def button_select_click(self, *username:str()):
		__username = username
		def button_select_click_login(self):
			print(self.__username)
		
	def __init__(self):
		ShowBase.__init__(self) #Insantziert das Hauptfenster, diese stellen immer eine Instanz der ShowBase-Klasse dar
		
		def button_enter_pressed():
			print("Die Taste Enter wurde gedrückt!")
			#print(label_input.get())
			us.createuser(label_input.get())
			app.finalizeExit()
		def user_select_button():
			print("Spielerauswahl-Button wurde gedrückt!")

		us = User.User()
		#Erstellt ein DialogFenster
		self.gameOverScreen = DirectDialog(frameSize = (-0.7, 0.7, -0.7, 0.7),
								   fadeScreen = 0.4,
								   relief = DGG.FLAT)
		
		#Erstellt einen Button zum Parent-Dialogfenster
		self.btn = DirectButton(text = "Quit",
						   command = self.quit,
						   pos = (0.3, 0, -0.2),
						   parent = self.gameOverScreen,
						   scale = 0.09)
		
		label_menu = DirectDialog(text="Hauptmenü", parent=self.gameOverScreen, scale = 1, pos=(0,0,0.5))
		if(us.checkuserdb() == False):
			#label_enter_name_msg = DirectDialog(parent=self.gameOverScreen, text="Gib deinen Namen ein:", scale=0.05, pos=(-0.6, 0.5,0))
			label_input = DirectEntry(parent=self.gameOverScreen, text="Name", width=15, scale = 0.05, pos=(-0.6,0.5,0), relief=DGG.SUNKEN)

		elif(us.checkuserdb() == True):
			pos_button_x = 0
			pos_button_y = 0
			for users in us.listallusers():
				label_users = DirectButton
				u = User_login(str(users), us, label_users)
				label_users = DirectButton(text=str(users), command=u.user_select, parent=self.gameOverScreen, scale=0.09, pos=(-0.5,0,pos_button_y))
				print(label_users)
				u.setButtonObject(label_users)
				pos_button_y -= 0.2

		#self.taskMgr.doMethodLater(0.2,self.exampleTask, "exampleTask") #Hängt einen zustäzlichen Task in den Taskmanager ein
		
		self.gameOverScreen.show()

		# Create scene 1
		self.scene1_background = self.loader.loadModel("data/panda_example/Environment/environment")
		self.scene1_background.reparentTo(self.render)
		self.scene1 = self.render.attachNewNode("Scene 1")
		self.scene1_text = OnscreenText(text="Scene 1", pos=(0, 0), scale=0.1, align=TextNode.ACenter)
		if(us.checkuserdb() == False):
			self.accept('enter', button_enter_pressed)
		self.scene1_text.show()
		

		# Create scene 2
		self.scene2 = self.render.attachNewNode("Scene 2")
		self.scene2_text = OnscreenText(text="Scene 2", pos=(0, 0), scale=0.1, align=TextNode.ACenter)
		self.scene2_text.hide()

		# Create toggle text
		self.toggle_text = OnscreenText(text="Toggle Scene: [SPACE] if it works!", pos=(0, -0.9), scale=0.08, align=TextNode.ACenter)

		# Set initial scene
		self.current_scene = 1

		# Set key bindings
		self.accept('space', self.toggle_scene)
		self.accept('escape', self.quit)

		# Position and orient the camera
		self.camera.setPos(0, -10, 0)  # Set camera position
		self.camera.lookAt(0, 0, 0)  # Point camera towards the origin
		"""
		for i in range(5):
			time.sleep(3)
			label_menu['text']	= "WOSCHT" + str(i)"""
 

	def toggle_scene(self):
		if self.current_scene == 1:
			self.scene1_text.hide()
			self.scene2_text.show()
			self.current_scene = 2
		else:
			self.scene2_text.hide()
			self.scene1_text.show()
			self.current_scene = 1

	def quit(self):
		#self.taskMgr.destroy() #Bereitet unter Linux Probleme
		#self.us.__del__(self.us)
		app.finalizeExit()
		
   
#Dieser Task wird bei Berechnungs jeden Frames ausgeführt
	"""
	x=0
	def exampleTask(self, task):
		self.btn['text'] = "Woscht" + str(self.x)
		if(self.x==200):
			return task.done
		self.x +=1
		return task.again
	"""
app = MyApp()
app.run()