from django.shortcuts import render, redirect
from django.contrib.auth.decorators import login_required
from django.http import JsonResponse
from .models import Workday, Breaks, FreeDays, AbsenceReason, Absence
from django.utils import timezone
import requests, csv, os
from django.templatetags.static import static
from django.conf import settings
from datetime import date
from django.contrib.auth.models import User
from calendar import monthrange
import datetime
import calendar
from .forms import AddAbsence, ConfirmAbsenceForm, UpdateAbsence, UpdateWorkdayForm, AddBreakForm, AddWorkdayForm
from django.contrib import messages
from users.models import UserFullName, UserYearAbsenceInfo
from users.models import UserTime
from datetime import timedelta
from django.db.models.signals import post_save
from users.signals import save_newabsence
import locale

# Load freedays
def loadingFreeDays(plz):
	# Getting land

	file_path = os.path.join(settings.STATIC_ROOT, 'users/extra/plz_short.csv')

	land = False

	with open(file_path, 'rt') as csvfile:
		filecsv = csv.reader(csvfile, delimiter=';')
		for row in filecsv:
			if row[1] == plz:
				land = row[6]
				break;

	if(land != False):
		# CALCULATE FREEDAYS AS JSON
		year = today = date.today().year


		URL = "https://feiertage-api.de/api/"
		PARAMS = {'jahr':year,'nur_land':land}
		r = requests.get(url = URL, params = PARAMS)
		return r.json()
	else:
		return False

def get_datetime_range(year, month):
    nb_days = monthrange(year, month)[1]
    return [datetime.date(year, month, day) for day in range(1, nb_days+1)]

@login_required
def AbsenceUpdate(request, pk):

	if request.method == "GET":
		absence = Absence.objects.get(pk=pk)
		timeinfo_thisyear = list(UserYearAbsenceInfo.objects.filter(year=absence.start.year, user=absence.user))[0]
		try:
			timeinfo_nextyear = list(UserYearAbsenceInfo.objects.filter(year=absence.start.year+1, user=absence.user))[0]
		except:
			timeinfo_nextyear = False

		context = {
			"active_link" : "abscence",
			"form" : UpdateAbsence(instance=request.user),
			"absence" : absence,
			"timeinfo_thisyear" : timeinfo_thisyear,
			"timeinfo_nextyear" : timeinfo_nextyear,
			"start" : absence.start.strftime("%d.%m.%Y"),
			"end" : absence.end.strftime("%d.%m.%Y"),
		}
		return render(request, 'timemanagement/tm_ab_update.html', context)
	elif request.method == "POST":
		absence = Absence.objects.get(pk=pk)
		formtocheck = UpdateAbsence(request.POST, instance=request.user)
		if(formtocheck.is_valid()):

			abinfo = list(UserYearAbsenceInfo.objects.filter(user=absence.user, year=absence.start.year))[0]
			abinfo_lastyear = ""
			abinfo_nextyear = ""

			is_lastyear = False

			abinfo_lastyear = list(UserYearAbsenceInfo.objects.filter(user=absence.user, year=absence.start.year-1))
			if(len(abinfo_lastyear) > 0):
				is_lastyear = True
				abinfo_lastyear = abinfo_lastyear[0]

			is_nextyear = False
			abinfo_nextyear = list(UserYearAbsenceInfo.objects.filter(user=absence.user, year=absence.start.year+1))
			if(len(abinfo_nextyear) > 0):
				is_nextyear = True
				abinfo_nextyear = abinfo_nextyear[0]

			abinfo.days_inuse -= formtocheck.cleaned_data["holidays_normal"]
			abinfo.restdays -= formtocheck.cleaned_data["holidays_rest"]
			abinfo.save()

			abinfo_nextyear.days_inuse -= formtocheck.cleaned_data["holidays_normal_next"]
			abinfo_nextyear.restdays -= formtocheck.cleaned_data["holidays_rest_next"]
			abinfo_nextyear.save()

			absence.start = formtocheck.cleaned_data["start"]
			absence.end = formtocheck.cleaned_data["end"]
			absence.startday_info = str(formtocheck.cleaned_data["startday_info"])
			absence.endday_info = str(formtocheck.cleaned_data["endday_info"])
			absence.reason = formtocheck.cleaned_data["reason"]

			rep = None
			if(formtocheck.cleaned_data["representator"] != None):
				rep = User.objects.get(pk=formtocheck.cleaned_data["representator"].pk)
			absence.representator = rep
			absence.info = formtocheck.cleaned_data["info"]

			absence.holidays_normal = 0.0
			absence.holidays_rest = 0.0
			absence.holidays_normal_next = 0.0
			absence.holidays_rest_next = 0.0
			absence.save()
			messages.success(request, f'Abwesenheit aktualisiert!')
		else:
			messages.success(request, f'Fehler bei Abwesenheitsaktualisierung!')
		context = {
			"active_link" : "abscence",
		}
		return redirect("tma-management")

@login_required
def AbsenceManagmenet(request, activemonth=False, activeyear=False):

	# NEW ABSENCE
	if(request.method == "POST"):
		'''

			Nachdem eine neue Abwesenheit gespeichert wurde, geht es zur normalen Seite zurück, jedoch mit den Daten des aktuell angezeigten Monate/Jahr

		'''
		if(request.POST.get("form_type") == "absenceform"):
			formtocheck = AddAbsence(request.POST, instance=request.user)
			if(formtocheck.is_valid()):

				try:
					workinguser = UserFullName.objects.get(pk=formtocheck.cleaned_data["userid"])

					# DIFFERENT USER AGENCY
					if(workinguser.profile.agency != request.user.profile.agency):
						messages.success(request, f'Das dürfen Sie nicht!')
						return redirect('tma-management', formtocheck.cleaned_data['activemonth'], formtocheck.cleaned_data['activeyear'])
					# ALL OK - START SAVING ABSENCE
					else:
						confirmstat = 0
						reason = AbsenceReason.objects.filter(name=formtocheck.cleaned_data["reason"], agency=request.user.profile.agency)[0]
						
						if(request.user.has_perm("users.absencemanager") == False and reason.need_confirm == True):
							confirmstat = 1
							messages.success(request, f'Abwesenheit beantragt')
							# SEND NOTIFICATION
						elif(request.user.has_perm("users.absencemanager") == False and reason.need_confirm == False):
							confirm_status = 0
							messages.success(request, f'Abwesenheit eingetragen')
						else:
							messages.success(request, f'Abwesenheit eingetragen')

						rep = None
						if(formtocheck.cleaned_data["representator"] != None):
							rep = User.objects.get(pk=formtocheck.cleaned_data["representator"].pk)

						#newab = Absence(agency=request.user.profile.agency, user=workinguser, start=formtocheck.cleaned_data["start"],end=formtocheck.cleaned_data["end"], representator=rep, confirm_status=confirmstat, info=formtocheck.cleaned_data["info"], reason=formtocheck.cleaned_data["reason"], start_ishalf=formtocheck.cleaned_data["start_ishalf"], end_ishalf=formtocheck.cleaned_data["end_ishalf"]).save()
						newab = Absence(agency=request.user.profile.agency, user=workinguser, start=formtocheck.cleaned_data["start"],end=formtocheck.cleaned_data["end"], representator=rep, confirm_status=confirmstat, info=formtocheck.cleaned_data["info"], reason=formtocheck.cleaned_data["reason"], startday_info=formtocheck.cleaned_data["startday_info"], endday_info=formtocheck.cleaned_data["endday_info"]).save()
				# USER NOT FOUND
				except:
					messages.success(request, f'Fehler bei Abwesenheitsbearbeitung! Bitte wenden Sie sich an den Support.')
					return redirect('tma-management', formtocheck.cleaned_data['activemonth'], formtocheck.cleaned_data['activeyear'])

				return redirect('tma-management', formtocheck.cleaned_data['activemonth'], formtocheck.cleaned_data['activeyear'])
			else:
				messages.success(request, f'Fehler beim eintragen der neuen Abwesenheit!')
				return redirect('tma-management', formtocheck.cleaned_data['activemonth'], formtocheck.cleaned_data['activeyear'])
		else:
			return redirect('tma-management')
	# NORMAL VIEW
	else:
		prevmonth = ""
		nextmonth = ""
		#MONTH
		if(not activemonth or activemonth > 12 or activemonth < 1):
			activemonth = int(activemonth)
			#Active month
			activemonth=date.today().month

			if(activemonth == 1):
				prevmonth = 12
			else:
				prevmonth = activemonth-1

			if(activemonth == 12):
				nextmonth = 1
			else:
				nextmonth = activemonth + 1
		else:

			if(activemonth == 1):
				prevmonth = 12
			else:
				prevmonth = activemonth-1

			if(activemonth == 12):
				nextmonth = 1
			else:
				nextmonth = activemonth + 1

		#YEAR
		nextyear = date.today().year
		prevyear = date.today().year

		if(not activeyear):
			activeyear = date.today().year
		else:
			if(nextmonth == 1):
				nextyear = activeyear + 1
			else:
				nextyear = activeyear
			if(prevmonth == 12):
				prevyear = activeyear - 1
			else:
				prevyear = activeyear

		missinguserdata = []
		#CHECK, ob alle nötigen Infos zur Urlaubsberechnung vorliegen
		for user in User.objects.filter(profile__agency=request.user.profile.agency):
			tempTime = UserTime.objects.get(user=user)

			if(tempTime.startdate == None):
				missinguserdata.append(user)

		kontingent = 0
		inuse = 0
		yearinfo = False
		try:
			yearinfo = list(UserYearAbsenceInfo.objects.filter(year=activeyear, user=request.user))[0]
			inuse = yearinfo.days_inuse
			kontingent = yearinfo.days - inuse
		except:
			pass


		# ABSENCE AUFLISTUNG NACH GRUND

		allreasons = AbsenceReason.objects.filter(agency=request.user.profile.agency).order_by("name")
		final_reasons = []
		for ar in allreasons:
			tempabsece = Absence.objects.filter(reason=ar, user=request.user, start__year=activeyear, confirm_status=0)
			temp_sum = 0.0
			for t in tempabsece:
				temp_sum += calculatingHolidaysByAbsence(request, t)
			final_reasons.append([ar, temp_sum])

		context = {
			"active_link" : "abscence",
			"usersofagency" : User.objects.filter(profile__agency=request.user.profile.agency).order_by("-last_name"),
			"days_this_month" : get_datetime_range(activeyear,activemonth),
			"nextmonth" : nextmonth,
			"missinguserdata" : missinguserdata,
			"prevmonth" : prevmonth,
			"nextyear" : nextyear,
			"prevyear" : prevyear,
			"activemonth" : activemonth,
			"activeyear" : activeyear,
			"inuse" : inuse,
			"final_reasons" : final_reasons,
			"yearinfo" : yearinfo,
			"kontingent" : kontingent,
			"today" : date.today(),
			"abscenceform" : AddAbsence(instance=request.user),
			"userown" : Absence.objects.filter(agency=request.user.profile.agency, user=request.user).order_by("-start")
		}

		if(request.user.has_perm("users.absencemanager")):
			context.update({
				"needtoconfirm" : Absence.objects.filter(agency=request.user.profile.agency, confirm_status=1).order_by("-start"),
				"allabsences" : Absence.objects.filter(agency=request.user.profile.agency).order_by("-start")
				})
		return render(request, 'timemanagement/tm_ab_management.html', context)


@login_required
def TimeManagementTeamSingle(request, pk, activemonth=False, activeyear=False):
	if(request.user.has_perm("users.usermanager")):
		# Setzt die Monatsausgabe auf Deutsch
		locale.setlocale(locale.LC_TIME, 'de_DE.UTF-8')
		user = User.objects.get(pk=pk)
		# Hier wird der Monat und das Jahr für die Buttons gebaut
		if(activemonth == False):
			today = datetime.datetime.today()
			active_month = str(today.strftime("%B"))
			active_year = str(today.strftime("%Y"))
			activemonth = today.month
		else:
			today = datetime.datetime(activeyear, activemonth, 1)
			active_month = activemonth
			active_month = str(today.strftime("%B"))
			active_year = str(today.strftime("%Y"))

		prev_year = active_year
		next_year = active_year

		next_month = today.month + 1
		if(next_month == 13):
			next_month = 1
			next_year = int(next_year) + 1

		prev_month = today.month - 1
		if(prev_month == 0):
			prev_month = 12
			prev_year = int(prev_year) - 1

		# Initialprüfung, ob Arbeitstage vorliegen
		tempworkday = Workday.objects.filter(agency=request.user.profile.agency, user=user).order_by("start").exclude(end=None)[:1]

		user_has_workdays = False
		if len(tempworkday) == 1:
			user_has_workdays = True

		# Hier werden nur die Arbeitstage gefiltert, die auch aktuell zur Ansicht stehen sollen
		context = {
			"next_month" : next_month,
			"breakmonthline" : date.today() - timedelta(days=30),
			"prev_month" : prev_month,
			"next_year" : next_year,
			"prev_year" : prev_year,
			"active_year" : int(active_year),
			"active_month" : active_month,
			"activemonth" : activemonth,
			"active_link" : "timemanagement",
			"days_this_month" : get_datetime_range(int(active_year), int(activemonth)),
			"workdays" : Workday.objects.filter(agency=request.user.profile.agency, user=user, start__month=activemonth, start__year=active_year).order_by("start").exclude(end=None),
			"userhasworkdays" : user_has_workdays,
			"user" : user
		}
		
		return render(request, 'timemanagement/timemanagement_teamview_single.html', context)	



	# Requestet User has no rights...
	else:
		messages.success(request, f'Das würfen Sie nicht!')
		return redirect("tm-management")	


@login_required
def TimeManagement(request, activemonth=False, activeyear=False):
	# Setzt die Monatsausgabe auf Deutsch
	locale.setlocale(locale.LC_TIME, 'de_DE.UTF-8')

	# Hier wird der Monat und das Jahr für die Buttons gebaut
	if(activemonth == False):
		today = datetime.datetime.today()
		active_month = str(today.strftime("%B"))
		active_year = str(today.strftime("%Y"))
		activemonth = today.month
	else:
		today = datetime.datetime(activeyear, activemonth, 1)
		active_month = activemonth
		active_month = str(today.strftime("%B"))
		active_year = str(today.strftime("%Y"))

	prev_year = active_year
	next_year = active_year

	next_month = today.month + 1
	if(next_month == 13):
		next_month = 1
		next_year = int(next_year) + 1

	prev_month = today.month - 1
	if(prev_month == 0):
		prev_month = 12
		prev_year = int(prev_year) - 1

	# Initialprüfung, ob Arbeitstage vorliegen
	tempworkday = Workday.objects.filter(agency=request.user.profile.agency, user=request.user).order_by("start").exclude(end=None)[:1]

	user_has_workdays = False
	if len(tempworkday) == 1:
		user_has_workdays = True

	# Hier werden nur die Arbeitstage gefiltert, die auch aktuell zur Ansicht stehen sollen
	context = {
		"next_month" : next_month,
		"breakmonthline" : date.today() - timedelta(days=30),
		"prev_month" : prev_month,
		"next_year" : next_year,
		"prev_year" : prev_year,
		"active_year" : int(active_year),
		"active_month" : active_month,
		"activemonth" : activemonth,
		"active_link" : "timemanagement",
		"days_this_month" : get_datetime_range(int(active_year), int(activemonth)),
		"workdays" : Workday.objects.filter(agency=request.user.profile.agency, user=request.user, start__month=activemonth, start__year=active_year).order_by("start").exclude(end=None),
		"userhasworkdays" : user_has_workdays
	}
	if(request.user.has_perm("users.usermanager")):
		context.update({"usersofagencytm" : User.objects.filter(profile__agency=request.user.profile.agency).order_by('last_name')})

	return render(request, 'timemanagement/timemanagement_management.html', context)

@login_required
def TimeUpdate(request, pk, team=0):
	workday = Workday.objects.get(pk=pk)
	user = workday.user

	if(request.method == "POST"):
		if(team == 0):
			form = UpdateWorkdayForm(request.POST, instance=request.user)
		else:
			form = UpdateWorkdayForm(request.POST, instance=user)	

		start = datetime.datetime(int(workday.start.year), int(workday.start.month), int(workday.start.day), int(((str(form["start"].value()).split(":"))[0])), int(((str(form["start"].value()).split(":"))[1])))

		end = datetime.datetime(int(workday.end.year), int(workday.end.month), int(workday.end.day), int(((str(form["end"].value()).split(":"))[0])), int(((str(form["end"].value()).split(":"))[1])))

		workday.start = start
		workday.end = end
		workday.target = form["target"].value()
		workday.save()
		messages.success(request, f'Arbeitstag aktualisiert')
		if(team == 1):
			return redirect('tm-team-single', user.pk, workday.start.month, workday.start.year)
		else:
			return redirect('tm-management')
	else:
		context = {
			"active_link" : "timemanagement",
			"workday" : Workday.objects.get(pk=pk),
			"form" : UpdateWorkdayForm(instance= Workday.objects.get(pk=pk)),
			"team" : team,
			"user" : workday.user
		}
		return render(request, 'timemanagement/timemanagement_update.html', context)

@login_required
def TimeAdd(request, team=0, pk=0):
	if(team == 0):
		user = request.user
		form = AddWorkdayForm(request.POST, instance=request.user)
	else:
		user = User.objects.get(pk=pk)
		form = AddWorkdayForm(request.POST, instance=user)

	if(request.method == "POST"):		
		if form.is_valid():
			#start = datetime.datetime(int(workday.start.year), int(workday.start.month), int(workday.start.day), int(((str(form["start"].value()).split(":"))[0])), int(((str(form["start"].value()).split(":"))[1])))

			#end = datetime.datetime(int(workday.end.year), int(workday.end.month), int(workday.end.day), int(((str(form["end"].value()).split(":"))[0])), int(((str(form["end"].value()).split(":"))[1])))

			workday = Workday(start=form.cleaned_data["start"], end=form.cleaned_data["end"], target=form.cleaned_data["target"], user=user, agency=request.user.profile.agency)

			if workday.start.day != workday.end.day or workday.start.month != workday.end.month or workday.start.year != workday.end.year or workday.start > workday.end:
				messages.success(request, f'Der Arbeitstag darf nur an einem Tag stattfinden und das Ende muss nach dem Anfang liegen.')
				context = {
					"active_link" : "timemanagement",
					"form" : AddWorkdayForm(),
					"team" : team,
					"user" : user
				}
				return render(request, 'timemanagement/timemanagement_add.html', context)
			else:
				workday.save()
				messages.success(request, f'Arbeitstag hinzugefügt')

				if (team == 1):
					return redirect('tm-team-single', user.pk, workday.start.month, workday.start.year)
				else:
					return redirect('tm-management')
		else:
			messages.success(request, f'Bitte valide Daten eingeben!')
			context = {
				"active_link" : "timemanagement",
				"form" : AddWorkdayForm(),
				"team" : team,
				"user" : user
			}
			return render(request, 'timemanagement/timemanagement_add.html', context)
	else:
		context = {
			"active_link" : "timemanagement",
			"form" : AddWorkdayForm(),
			"team" : team,
			"user" : user
		}		
		return render(request, 'timemanagement/timemanagement_add.html', context)

@login_required
def AddBreak(request, pk, team=0):
	workday = Workday.objects.get(pk=pk)
	user = workday.user
	if(request.method == "POST"):
		if(team == 0):
			form = AddBreakForm(request.POST, instance=request.user)
		else:
			form = AddBreakForm(request.POST, instance=user)

		start = datetime.datetime(int(workday.start.year), int(workday.start.month), int(workday.start.day), int(((str(form["start"].value()).split(":"))[0])), int(((str(form["start"].value()).split(":"))[1])))

		end = datetime.datetime(int(workday.end.year), int(workday.end.month), int(workday.end.day), int(((str(form["end"].value()).split(":"))[0])), int(((str(form["end"].value()).split(":"))[1])))

		if(team == 0):
			newbreak = Breaks.objects.create(workday=workday, user=request.user, agency=request.user.profile.agency, start=start, end=end)
		else:
			newbreak = Breaks.objects.create(workday=workday, user=user, agency=user.profile.agency, start=start, end=end)

		workday.breaks.add(newbreak)
		workday.save()
		messages.success(request, f'Pause hinzugefügt')

		if(team == 0):
			return redirect('tm-update', pk=pk)
		else:
			return redirect('tm-team-single', user.pk, workday.start.month, workday.start.year)
	else:
		if(team == 0):
			context = {
				"active_link" : "timemanagement",
				"workday" : Workday.objects.get(pk=pk),
				"form" : AddBreakForm(instance=request.user)
			}
		else:
			context = {
				"active_link" : "timemanagement",
				"workday" : Workday.objects.get(pk=pk),
				"form" : AddBreakForm(instance=user)
			}
		return render(request, 'timemanagement/timemanagement_break.html', context)

@login_required
def TimeAjax(request):
	data = {}
	if request.method == "GET":
		# START WORKDAY
		if request.GET["action"] == "start_day":

			today = date.today()
			targettime = 0.0
			if(today.isoweekday() == 1):
				targettime = request.user.usertime.wd_mo
			elif(today.isoweekday() == 2):
				targettime = request.user.usertime.wd_tu
			elif(today.isoweekday() == 3):
				targettime = request.user.usertime.wd_we
			elif(today.isoweekday() == 4):
				targettime = request.user.usertime.wd_th
			elif(today.isoweekday() == 5):
				targettime = request.user.usertime.wd_fr
			elif(today.isoweekday() == 6):
				targettime = request.user.usertime.wd_sa
			elif(today.isoweekday() == 7):
				targettime = request.user.usertime.wd_so

			wd = Workday(user=request.user, agency=request.user.profile.agency, start=timezone.now(), target=targettime)
			wd.save()

			data = {
				"success" : True,
				"wd_starttime" : wd.start.strftime("%H:%M:%S"),
				"wd_starttime_complete"	 : wd.start
			}
		# END DAY
		elif request.GET["action"] == "end_day":
			wd = list(Workday.objects.filter(user=request.user, agency=request.user.profile.agency, end=None))[0]
			# END ALL BREAKS
			for b in wd.breaks.all():
				if b.end == None:
					b.end = timezone.now()
					b.save()
			wd.end = timezone.now()
			wd.save()

			breaksum = 0
			for b in wd.breaks.all():
				if(b.end != None):
					breaksum += (b.end - b.start).seconds

			data = {
				"success" : True,
				"wd_endtime" : wd.end.strftime("%H:%M:%S"),
				"actualbreaktime" : breaksum*1000
			}
		# START A BREAK
		elif request.GET["action"] == "start_break":
			wd = list(Workday.objects.filter(user=request.user, agency=request.user.profile.agency, end=None))[0]
			newbreak = Breaks(workday=wd, user=request.user, agency=request.user.profile.agency, start=timezone.now())
			newbreak.save()
			wd.breaks.add(newbreak)
			data = {
				"success" : True,
				"break_starttime" : newbreak.start,
			}
		# END BREAK
		elif request.GET["action"] == "end_break":
			wd = list(Workday.objects.filter(user=request.user, agency=request.user.profile.agency, end=None))[0]
			toendbreak = list(wd.breaks.filter(end=None))[0]
			toendbreak.end = timezone.now()
			toendbreak.save()

			wd = list(Workday.objects.filter(user=request.user, agency=request.user.profile.agency, end=None))[0]
			breaksum = 0
			for b in wd.breaks.all():
				if(b.end != None):
					breaksum += (b.end - b.start).seconds

			data = {
				"success" : True,
				"actualbreaktime" : breaksum*1000
			}
		# REMOVE WORKDAY
		elif request.GET["action"] == "remove_workday":
			wd = Workday.objects.get(pk=request.GET.get("workday"))
			if(wd.agency == request.user.profile.agency):
				wd.delete()
				data = {
					"success" : True
				}
			else:
				data = { "success" : False}
		# REMOVE BREAK
		elif request.GET["action"] == "remove_break":
			breakwd = Breaks.objects.get(pk=request.GET.get("break"))
			if(breakwd.agency == request.user.profile.agency):
				breakwd.delete()
				data = {
					"success" : True
				}
			else:
				data = { "success" : False}
		# LOADING INTIAIL WORKDAYS
		elif request.GET["action"] == "initial_load":

			allfreedays = FreeDays.objects.filter(agency=request.user.profile.agency, day__gt=request.user.usertime.usetime_start, day__lt=date.today())


			weekdays = [6,7]
			for dt in daterange(request.user.usertime.usetime_start, date.today()):
				if dt.isoweekday() not in weekdays:
					in_freedays = False
					for freeday in allfreedays.all():
						if(dt == freeday.day):
							in_freedays = True
							break;

					if(not in_freedays):
						# MONDAY
						if(dt.isoweekday() == 1):
							start_time = datetime.timedelta(hours=8)
							start_date = datetime.date(int(dt.year), int(dt.month), int(dt.day))
							end_time = datetime.timedelta(hours=request.user.usertime.wd_mo) + start_time
							time_start = datetime.datetime.strptime(str(start_time), "%H:%M:%S").time()
							time_end = datetime.datetime.strptime(str(end_time), "%H:%M:%S").time()
							start_datetime = datetime.datetime.combine(start_date, time_start)
							end_datetime = datetime.datetime.combine(start_date, time_end)

							Workday.objects.create(user=request.user, agency=request.user.profile.agency, start=start_datetime, end=end_datetime, target=request.user.usertime.wd_mo)
						if(dt.isoweekday() == 2):
							start_time = datetime.timedelta(hours=8)
							start_date = datetime.date(int(dt.year), int(dt.month), int(dt.day))
							end_time = datetime.timedelta(hours=request.user.usertime.wd_tu) + start_time
							time_start = datetime.datetime.strptime(str(start_time), "%H:%M:%S").time()
							time_end = datetime.datetime.strptime(str(end_time), "%H:%M:%S").time()
							start_datetime = datetime.datetime.combine(start_date, time_start)
							end_datetime = datetime.datetime.combine(start_date, time_end)

							Workday.objects.create(user=request.user, agency=request.user.profile.agency, start=start_datetime, end=end_datetime, target=request.user.usertime.wd_tu)
						if(dt.isoweekday() == 3):
							start_time = datetime.timedelta(hours=8)
							start_date = datetime.date(int(dt.year), int(dt.month), int(dt.day))
							end_time = datetime.timedelta(hours=request.user.usertime.wd_we) + start_time
							time_start = datetime.datetime.strptime(str(start_time), "%H:%M:%S").time()
							time_end = datetime.datetime.strptime(str(end_time), "%H:%M:%S").time()
							start_datetime = datetime.datetime.combine(start_date, time_start)
							end_datetime = datetime.datetime.combine(start_date, time_end)

							Workday.objects.create(user=request.user, agency=request.user.profile.agency, start=start_datetime, end=end_datetime, target=request.user.usertime.wd_we)
						if(dt.isoweekday() == 4):
							start_time = datetime.timedelta(hours=8)
							start_date = datetime.date(int(dt.year), int(dt.month), int(dt.day))
							end_time = datetime.timedelta(hours=request.user.usertime.wd_th) + start_time
							time_start = datetime.datetime.strptime(str(start_time), "%H:%M:%S").time()
							time_end = datetime.datetime.strptime(str(end_time), "%H:%M:%S").time()
							start_datetime = datetime.datetime.combine(start_date, time_start)
							end_datetime = datetime.datetime.combine(start_date, time_end)

							Workday.objects.create(user=request.user, agency=request.user.profile.agency, start=start_datetime, end=end_datetime, target=request.user.usertime.wd_th)
						if(dt.isoweekday() == 5):
							start_time = datetime.timedelta(hours=8)
							start_date = datetime.date(int(dt.year), int(dt.month), int(dt.day))
							end_time = datetime.timedelta(hours=request.user.usertime.wd_fr) + start_time
							time_start = datetime.datetime.strptime(str(start_time), "%H:%M:%S").time()
							time_end = datetime.datetime.strptime(str(end_time), "%H:%M:%S").time()
							start_datetime = datetime.datetime.combine(start_date, time_start)
							end_datetime = datetime.datetime.combine(start_date, time_end)

							Workday.objects.create(user=request.user, agency=request.user.profile.agency, start=start_datetime, end=end_datetime, target=request.user.usertime.wd_fr)

						if(dt.isoweekday() == 6):
							start_time = datetime.timedelta(hours=8)
							start_date = datetime.date(int(dt.year), int(dt.month), int(dt.day))
							end_time = datetime.timedelta(hours=request.user.usertime.wd_sa) + start_time
							time_start = datetime.datetime.strptime(str(start_time), "%H:%M:%S").time()
							time_end = datetime.datetime.strptime(str(end_time), "%H:%M:%S").time()
							start_datetime = datetime.datetime.combine(start_date, time_start)
							end_datetime = datetime.datetime.combine(start_date, time_end)

							Workday.objects.create(user=request.user, agency=request.user.profile.agency, start=start_datetime, end=end_datetime, target=request.user.usertime.wd_sa)

						if(dt.isoweekday() == 7):
							start_time = datetime.timedelta(hours=8)
							start_date = datetime.date(int(dt.year), int(dt.month), int(dt.day))
							end_time = datetime.timedelta(hours=request.user.usertime.wd_so) + start_time
							time_start = datetime.datetime.strptime(str(start_time), "%H:%M:%S").time()
							time_end = datetime.datetime.strptime(str(end_time), "%H:%M:%S").time()
							start_datetime = datetime.datetime.combine(start_date, time_start)
							end_datetime = datetime.datetime.combine(start_date, time_end)

							Workday.objects.create(user=request.user, agency=request.user.profile.agency, start=start_datetime, end=end_datetime, target=request.user.usertime.wd_so)
		# Get Rendered Table
		elif request.GET["action"] == "getrenderedtable":
			prevmonth = ""
			nextmonth = ""
			activemonth = int(request.GET["activemonth"])
			activeyear = int(request.GET["activeyear"])

			#MONTH
			if(not activemonth or activemonth > 12 or activemonth < 1):
				activemonth = int(activemonth)
				#Active month
				activemonth=date.today().month

				if(activemonth == 1):
					prevmonth = 12
				else:
					prevmonth = activemonth-1

				if(activemonth == 12):
					nextmonth = 1
				else:
					nextmonth = activemonth + 1
			else:

				if(activemonth == 1):
					prevmonth = 12
				else:
					prevmonth = activemonth-1

				if(activemonth == 12):
					nextmonth = 1
				else:
					nextmonth = activemonth + 1

			#YEAR
			nextyear = date.today().year
			prevyear = date.today().year

			if(not activeyear):
				activeyear = date.today().year
			else:
				if(nextmonth == 1):
					nextyear = activeyear + 1
				else:
					nextyear = activeyear
				if(prevmonth == 12):
					prevyear = activeyear - 1
				else:
					prevyear = activeyear
			missinguserdata = []
			#CHECK, ob alle nötigen Infos zur Urlaubsberechnung vorliegen
			for user in User.objects.filter(profile__agency=request.user.profile.agency):
				tempTime = UserTime.objects.get(user=user)

				if(tempTime.startdate == None):
					missinguserdata.append(user)

			context = {
				"active_link" : "abscence",
				"usersofagency" : User.objects.filter(profile__agency=request.user.profile.agency).order_by("-last_name"),
				"days_this_month" : get_datetime_range(activeyear,activemonth),
				"activemonth" : activemonth,
				"missinguserdata" : missinguserdata,
				"activeyear" : activeyear,
				"nextmonth" : nextmonth,
				"prevmonth" : prevmonth,
				"nextyear" : nextyear,
				"prevyear" : prevyear,
				"today" : date.today(),
			}
			return render(request, "timemanagement/rendered_table.html", context)

		# Prüfung, ob eine Vertretung nötig ist oder nicht
		elif request.GET["action"] == "checkrequired":
			reason = AbsenceReason.objects.get(pk=request.GET["rid"])
			if(reason.agency == request.user.profile.agency):
				data = {
					"success" : True,
					"isreq" : reason.need_rep,
					"isholiday" : reason.is_holiday
				}
			else:
				data = {
					"success" : False
				}
		# DELETE ABSENCE
		elif request.GET["action"] == "remove_absence":
			absence = Absence.objects.get(pk=request.GET["ab"])

			if(request.user.has_perm("users.absencemanager") and absence.agency == request.user.profile.agency):
				absence.delete()
				data = {
					"success" : True
				}
		# GET FORM FOR CONFIRM ABSENCE
		elif request.GET["action"] == "getrenderedform":

			absence = Absence.objects.get(pk=request.GET["abscenceid"])
			timeinfo_thisyear = list(UserYearAbsenceInfo.objects.filter(year=absence.start.year, user=absence.user))[0]
			try:
				timeinfo_nextyear = list(UserYearAbsenceInfo.objects.filter(year=absence.start.year+1, user=absence.user))[0]
			except:
				timeinfo_nextyear = False


			# POrüfen, ob es in diesem Zeitraum noch andere Abwesenheiten gibt
			other_absences = Absence.objects.filter(start__lte=absence.start, end__gte=absence.end, agency=request.user.profile.agency, confirm_status=0).exclude(user=absence.user)

			other_absences_string = False
			if (len(other_absences) > 0):
				other_absences_string = []
				for a in other_absences:
					other_absences_string.append(a.user.first_name + " " + a.user.last_name + " - Vom " + a.start.strftime("%d.%m.%Y") + " bis " + a.end.strftime("%d.%m.%Y"))


			context = {
				"confirmform" : ConfirmAbsenceForm(instance=request.user),
				"absence" : absence,
				"other_absences_string" : other_absences_string,
				"timeinfo_thisyear" : timeinfo_thisyear,
				"timeinfo_nextyear" : timeinfo_nextyear
			}

			return render(request, "timemanagement/rendered_confirmform.html", context)
		elif request.GET["action"] == "confirmornotabscence":
			absence = Absence.objects.get(pk=request.GET["absencetowork"])
			new_stat = request.GET["newconfstat"]

			info = request.GET["info"]
			# Eingeloggter Nutzer hat Rechte, Urlaube einzutragen
			if(absence.user.profile.agency == request.user.profile.agency and request.user.has_perm("users.absencemanager")):
				absence.confirm_status = new_stat

				# Wenn eine Abwesenheit abgelehnt wurde, werden hier die Tage wieder auf das Kontingent geschrieben. Die Abewesenheit selber wird aber nicht gelöscht, sondern ist dann einfach "leer"
				if(new_stat == "2"):
					year = absence.start.year
					userabinfo_thisyear = list(UserYearAbsenceInfo.objects.filter(user=absence.user, year=year))[0]
					userabinfo_nextyear = list(UserYearAbsenceInfo.objects.filter(user=absence.user, year=year+1))[0]

					userabinfo_thisyear.days_inuse = userabinfo_thisyear.days_inuse - absence.holidays_normal - absence.holidays_rest
					userabinfo_thisyear.restdays = userabinfo_thisyear.restdays + absence.holidays_rest

					userabinfo_nextyear.days_inuse = userabinfo_nextyear.days_inuse - absence.holidays_normal_next - absence.holidays_rest_next
					userabinfo_nextyear.restdays = userabinfo_nextyear.restdays + absence.holidays_rest_next

					userabinfo_thisyear.save()
					userabinfo_nextyear.save()

					absence.holidays_normal = 0
					absence.holidays_rest = 0
					absence.holidays_normal_next = 0
					absence.holidays_rest_next = 0


				absence.confirm_info = info
				post_save.disconnect(save_newabsence, sender=Absence)
				absence.save()
				post_save.connect(save_newabsence, sender=Absence)
				messages.success(request, f'Abwesenheit gespeichert!')
			else:
				messages.success(request, f'Das dürfen Sie nicht!')

			data = {
				"success" : True,
				"activemonth" : request.GET["activemonth"],
				"activeyear" : request.GET["activeyear"]
			}
		# Berechnung starten, da Urlaub vorhanden ist
		elif request.GET["action"] == "getrestholidays":
			user = User.objects.get(pk=request.GET["userid"])
			usertimedata = UserTime.objects.get(user=user)
			today = date.today()
			if(user.profile.agency == request.user.profile.agency):

				start_day = request.GET["startdate"].split("__")
				start_day_obj = datetime.date(int(start_day[0]), int(start_day[1]), int(start_day[2]))

				end_day = request.GET["enddate"].split("__")
				end_day_obj = datetime.date(int(end_day[0]), int(end_day[1]), int(end_day[2]))

				try:
					holidayloose_date = datetime.date(start_day_obj.year, int(usertimedata.loose_holidedate.split(".")[1]), int(usertimedata.loose_holidedate.split(".")[0]))
				except:
					holidayloose_date = datetime.date(2020, int(usertimedata.loose_holidedate.split(".")[1]), int(usertimedata.loose_holidedate.split(".")[0]))


				# GET INFO IF DAY IS HALF OR NOT, EQUAL PRE-POST-DAY
				start_half = False
				if request.GET["startday_info"] == "1" or request.GET["startday_info"] == "2":
					start_half = True

				end_half = False
				if request.GET["endday_info"] == "1" or request.GET["endday_info"] == "2":
					end_half = True

				choosenyear = int(start_day[0])

				yeardata = list(UserYearAbsenceInfo.objects.filter(user=user, agency=user.profile.agency, year=choosenyear))[0]

				holiday_thisyear = 0
				holiday_lastyear = yeardata.restdays
				holiday_nextyear = 0
				holiday_nextyear_rest = 0
				two_years = False
				need_days_next = 0
				need_days_this = 0

				try:
					holiday_nextyear = list(UserYearAbsenceInfo.objects.filter(user=user, agency=user.profile.agency,
						year=choosenyear+1))[0].days - list(UserYearAbsenceInfo.objects.filter(user=user, agency=user.profile.agency,
						year=choosenyear+1))[0].days_inuse
					holiday_nextyear_rest = list(UserYearAbsenceInfo.objects.filter(user=user, agency=user.profile.agency,
						year=choosenyear+1))[0].restdays
				except:
					holiday_nextyear = yeardata.days

				# Urlaub innerhalb eines Jahres inkl. Prüfung auf Resturlaubsanspruch
				if(end_day_obj.year == start_day_obj.year):
					# Startt des Urlaubs NACH Verfallsdatum - nur aktuelles JAhr und die Zahl interessiert
					if(start_day_obj > holidayloose_date):
						need_days = (calculateHolidays(request, start_day_obj, end_day_obj, start_half, end_half, user))*(-1)
						holiday_thisyear =  yeardata.days - yeardata.days_inuse - need_days
					else:
						need_days = (calculateHolidays(request, start_day_obj, end_day_obj, start_half, end_half, user))*(-1)
						# Kein Resturlaub
						if(yeardata.restdays == 0.0):
							holiday_thisyear =  yeardata.days - yeardata.days_inuse - need_days
						# Resturlaub vorhanden, berechne mit Resturlaub
						else:
							holiday_lastyear = yeardata.restdays
							holiday_thisyear = yeardata.days - yeardata.days_inuse
							temp_holiday = holiday_lastyear - need_days
							if(temp_holiday < 0):
								holiday_lastyear = 0
								holiday_thisyear =  yeardata.days - yeardata.days_inuse + temp_holiday
							else:
								holiday_lastyear =  yeardata.restdays - need_days
				# Urlaub geht über das nächstes Jahr hinweg
				else:
					two_years = True
					holiday_lastyear =  yeardata.restdays
					date_splitter = datetime.date(end_day_obj.year, 1, 1)

					need_days_this = (calculateHolidays(request, start_day_obj, date_splitter, start_half, False), user)*(-1)

					need_days_next = (calculateHolidays(request, date_splitter, end_day_obj, False, end_half, user))*(-1)

					need_days = (calculateHolidays(request, start_day_obj, date_splitter, start_half, False, user))*(-1) + (calculateHolidays(request, date_splitter, end_day_obj, False, end_half))*(-1)
					holiday_thisyear = yeardata.days - yeardata.days_inuse - need_days_this
					days_nextyear_normal = 0
					days_nextyear_rest = 0
					# Urlaub nächstes Jahr MIT und OHNE Rest
					if(holiday_nextyear_rest == 0.0):
						holiday_nextyear = holiday_nextyear - (calculateHolidays(request, date_splitter, end_day_obj, False, end_half, user))*(-1)
					else:
						temprest = holiday_nextyear_rest - need_days_next
						# Rest reicht!
						if(temprest >= 0):
							holiday_nextyear_rest = temprest
							days_nextyear_normal = 0
							days_nextyear_rest = need_days_next
						# Rest reicht nicht
						else:
							holiday_nextyear_rest = 0
							holiday_nextyear += temprest
							days_nextyear_rest = need_days_next + temprest
							days_nextyear_normal = temprest * -1

				# POrüfen, ob es in diesem Zeitraum noch andere Abwesenheiten gibt
				other_absences = Absence.objects.filter(start__lte=start_day_obj, end__gte=end_day_obj, agency=request.user.profile.agency, confirm_status=0).exclude(user=user)

				other_absences_string = False
				if (len(other_absences) > 0):
					other_absences_string = ""
					for a in other_absences:
						other_absences_string += a.user.first_name + " " + a.user.last_name + " - Vom " + a.start.strftime("%d.%m.%Y") + " bis " + a.end.strftime("%d.%m.%Y") + "<br />"

				# Prüfen, ob der Nutzer selbst schon Abwesenheiten in diesem Zeitraum hat

				userown_absences = Absence.objects.filter(start__lte=start_day_obj, end__gte=end_day_obj, agency=request.user.profile.agency, user=user, confirm_status=0)

				userown_absences_string = False
				if (len(userown_absences) > 0):
					userown_absences_string = ""
					for a in userown_absences:
						userown_absences_string += a.reason.name + " - Vom " + a.start.strftime("%d.%m.%Y") + " bis " + a.end.strftime("%d.%m.%Y") + "<br />"

				data = {
					"restholiday_thisyear" : holiday_thisyear,
					"restholiday_lastyear" : holiday_lastyear,
					"restholiday_nextyear" : holiday_nextyear,
					"restholiday_nextyear_rest" : holiday_nextyear_rest,
					"two_years" : two_years,
					"need_days" : need_days,
					"need_days_next" : need_days_next,
					"need_days_this" : need_days_this,
					"other_absences" : other_absences_string,
					"userown_absences" : userown_absences_string,
					"choosenuser_name" : user.first_name + " " + user.last_name
				}
			# REQUEST USER NO RIGHTS
			else:
				data = {
					"success" : False
				}
	# GET REQUEST ACTION UNKNOWN
	else:
		data = {
			"success" : False
		}

	return JsonResponse(data)


'''

Gibt einen Integer zurück, welcher die Urlaubstage von Start zu Enddatum auf der Grundlage von Freitagen berechnet.
Berücksichtigt sowohl Wochenende als auch in der Agentur hinterlegte Freitage/Schließtage

'''
@login_required
def calculateHolidays(request, start, end, start_half, end_half, user):
	restdays = 0
	allfreedays = FreeDays.objects.filter(agency=request.user.profile.agency)
	if(end == start):
		if(start_half):
			return restdays - 0.5
		else:
			return restdays - 1
	else:
		if(end < start):
			return False
		else:
			counter = 0
			if(start_half):
				counter -= 0.5
			if(end_half):
				counter -= 0.5

			weekdays = []
			freedaycounter = 0
			for dt in daterange(start, end):

				if dt.isoweekday() not in weekdays:
					counter += 1
					for freeday in allfreedays.all():
						if(dt == freeday.day):
							freedaycounter += 1

					# Prüfung, ob der Mitarbeiter an diesem Tag überhaupt arbeitet. Wenn nicht, wird der Freedaycounter einfach erhöht
					if(dt.isoweekday() == 1):
						if user.usertime.wd_mo == 0.0:
							freedaycounter += 1
					elif(dt.isoweekday() == 2):
						if user.usertime.wd_tu == 0.0:#
							freedaycounter += 1
					elif(dt.isoweekday() == 3):
						if user.usertime.wd_we == 0.0:
							freedaycounter += 1
					elif(dt.isoweekday() == 4):
						if user.usertime.wd_th == 0.0:
							freedaycounter += 1
					elif(dt.isoweekday() == 5):
						if user.usertime.wd_fr == 0.0:
							freedaycounter += 1
					elif(dt.isoweekday() == 6):
						if user.usertime.wd_sa == 0.0:
							freedaycounter += 1
					elif(dt.isoweekday() == 7):
						if user.usertime.wd_so == 0.0:
							freedaycounter += 1


			return restdays - counter + freedaycounter

@login_required
def calculatingHolidaysByAbsence(request, absence):
	# Freitage laden, die innerhalb der gewünschten Abwesenheit liegen
	allfreedays = FreeDays.objects.filter(agency=request.user.profile.agency, day__gt=absence.start, day__lt=absence.end)
	finalholidayinabsence = 0

	# Start und Ende gleich, nur ein Tag. Checken, ob Halber Tag

	if(absence.start == absence.end):
		if absence.startday_info == "1" or absence.startday_info == "2":
			finalholidayinabsence = 0.5
		else:
			finalholidayinabsence = 1
		return finalholidayinabsence

	else:
		if absence.startday_info == "1" or absence.startday_info == "2":
			finalholidayinabsence -= 0.5
		if absence.endday_info == "1" or absence.endday_info == "2":
			finalholidayinabsence -= 0.5

		weekdays = []
		freedaycounter = 0
		for dt in daterange(absence.start, absence.end):

			if dt.isoweekday() not in weekdays:
				finalholidayinabsence += 1
				# Prüfung, ob freie Tage vorhanden sind
				for freeday in allfreedays.all():
					# FREEDAY FOUND
					if(dt == freeday.day):
						freedaycounter += 1
				# Prüfung, ob der Mitarbeiter an diesem Tag überhaupt arbeitet. Wenn nicht, wird der Freedaycounter einfach erhöht
				stat = False
				if(dt.isoweekday() == 1):
					if absence.user.usertime.wd_mo == 0.0:
						freedaycounter += 1
				elif(dt.isoweekday() == 2):
					if absence.user.usertime.wd_tu == 0.0:#
						freedaycounter += 1
				elif(dt.isoweekday() == 3):
					if absence.user.usertime.wd_we == 0.0:
						freedaycounter += 1
				elif(dt.isoweekday() == 4):
					if absence.user.usertime.wd_th == 0.0:
						freedaycounter += 1
				elif(dt.isoweekday() == 5):
					if absence.user.usertime.wd_fr == 0.0:
						freedaycounter += 1
				elif(dt.isoweekday() == 6):
					if absence.user.usertime.wd_sa == 0.0:
						freedaycounter += 1
				elif(dt.isoweekday() == 7):
					if absence.user.usertime.wd_so == 0.0:
						freedaycounter += 1

		return finalholidayinabsence - freedaycounter

# Gibt die Woche als Wochentage zurück
def daterange(date1, date2):
    for n in range(int ((date2 - date1).days)+1):
        yield date1 + timedelta(n)