package endpoints

import (
	"arbeitszeitmessung/helper"
	"arbeitszeitmessung/models"
	"arbeitszeitmessung/templates"
	"context"
	"database/sql"
	"encoding/json"
	"log"
	"net/http"
	"sort"
	"strconv"
	"time"
)

// Frontend relevant backend functionality -> not used by the arduino devices
func TimeHandler(w http.ResponseWriter, r *http.Request) {
	helper.RequiresLogin(Session, w, r)
	helper.SetCors(w)
	switch r.Method {
	case http.MethodGet:
		getBookings(w, r)
	case http.MethodPost:
		updateBooking(w, r)
	case http.MethodOptions:
		// just support options header for non GET Requests from SWAGGER
		w.WriteHeader(http.StatusOK)
	default:
		http.Error(w, "Method not allowed!", http.StatusMethodNotAllowed)
	}
}

func AbsencHandler(w http.ResponseWriter, r *http.Request) {
	helper.RequiresLogin(Session, w, r)
	helper.SetCors(w)
	switch r.Method {
	case http.MethodPost:
		err := updateAbsence(r)
		if err != nil {
			http.Error(w, "Internal error", http.StatusInternalServerError)
			return
		}
		http.Redirect(w, r, "/time", 301)
	default:
		http.Error(w, "Method not allowed!", http.StatusMethodNotAllowed)
	}
}

func parseTimestamp(r *http.Request, getKey string, fallback string) (time.Time, error) {
	getTimestamp := r.URL.Query().Get(getKey)
	if getTimestamp == "" {
		getTimestamp = fallback
	}
	Timestamp, err := time.Parse("2006-01-02", getTimestamp)
	if err != nil {
		return time.Now(), err
	}
	return Timestamp, nil
}

// Returns bookings from DB with similar card uid -> checks for card uid in http query params
func getBookings(w http.ResponseWriter, r *http.Request) {
	user, err := models.GetUserFromSession(Session, r.Context())
	if err != nil {
		log.Println("No user found with the given personal number!")
		http.Redirect(w, r, "/user/login", http.StatusSeeOther)
		return
	}

	// TODO add config for timeoffset
	tsFrom, err := parseTimestamp(r, "time_from", time.Now().AddDate(0, -1, 0).Format("2006-01-02"))
	if err != nil {
		log.Println("Error parsing 'from' time", err)
		http.Error(w, "Timestamp 'from' cannot be parsed!", http.StatusBadRequest)
		return
	}
	tsTo, err := parseTimestamp(r, "time_to", time.Now().Format("2006-01-02"))
	if err != nil {
		log.Println("Error parsing 'to' time", err)
		http.Error(w, "Timestamp 'to' cannot be parsed!", http.StatusBadRequest)
		return
	}
	tsTo = tsTo.AddDate(0, 0, 1) // so that today is inside

	days := models.GetDays(user, tsFrom, tsTo, true)
	sort.Slice(days, func(i, j int) bool {
		return days[i].Date().After(days[j].Date())
	})

	lastSub := user.GetLastWorkWeekSubmission()
	var aggregatedOvertime time.Duration
	for _, day := range days {
		if day.Date().Before(lastSub) {
			continue
		}
		aggregatedOvertime += day.TimeOvertimeReal(user)
	}
	if reportedOvertime, err := user.GetReportedOvertime(); err == nil {
		user.Overtime = (reportedOvertime + aggregatedOvertime).Round(time.Minute)
	} else {
		log.Println("Cannot calculate overtime: ", err)
	}

	if r.Header.Get("Accept") == "application/json" {
		w.Header().Set("Content-Type", "application/json")
		w.WriteHeader(http.StatusOK)
		json.NewEncoder(w).Encode(days)
		return
	}

	ctx := context.WithValue(r.Context(), "user", user)
	ctx = context.WithValue(ctx, "days", days)
	templates.TimePage([]models.WorkDay{}, lastSub).Render(ctx, w)
}

func updateBooking(w http.ResponseWriter, r *http.Request) {
	r.ParseForm()
	var loc *time.Location
	loc, err := time.LoadLocation(helper.GetEnv("TZ", "Europe/Berlin"))
	if err != nil {
		log.Println("Error loading location", err)
		loc = time.Local
	}
	user, err := models.GetUserFromSession(Session, r.Context())
	if err != nil {
		log.Println("No user found!", err)
		return
	}
	switch r.FormValue("action") {
	case "add":
		timestamp, err := time.ParseInLocation("2006-01-02|15:04", r.FormValue("date")+"|"+r.FormValue("timestamp"), loc)
		if err != nil {
			log.Println("Error parsing timestamp", err)
			return
		}

		var check_in_out int
		check_in_out, err = strconv.Atoi(r.FormValue("check_in_out"))
		if err != nil {
			log.Println("Error parsing check_in_out", err)
			return
		}

		newBooking := (*models.Booking).New(nil, user.CardUID, 0, int16(check_in_out), 1)
		newBooking.Timestamp = timestamp
		err = newBooking.InsertWithTimestamp()
		if err != nil {
			log.Printf("Error inserting booking %v -> %v\n", newBooking, err)
		}
	case "change":
		absenceType, err := strconv.Atoi(r.FormValue("absence"))
		if err != nil {
			log.Println("Error parsing absence type.", err)
			absenceType = 0
		}
		if absenceType != 0 {
			createAbsence(absenceType, user, loc, r)
		}
		for index, possibleBooking := range r.PostForm {
			if len(index) > 7 && index[:7] == "booking" {
				booking_id, err := strconv.Atoi(index[8:])
				if err != nil {
					log.Println("Error parsing bookingId", err)
					continue
				}
				booking, err := (*models.Booking).GetBookingById(nil, booking_id)
				if err != nil {
					log.Println("Error getting booking!", err)
					continue
				}
				parsedTime, err := time.ParseInLocation("15:04", possibleBooking[0], booking.Timestamp.Location())
				if err != nil {
					log.Println("Error parsing time!", err)
					continue
				}
				// log.Println("Parsing time", parsedTime)
				booking.UpdateTime(parsedTime)
			}
		}
	}
	getBookings(w, r)
}

func updateAbsence(r *http.Request) error {
	r.ParseForm()
	var loc *time.Location
	loc, err := time.LoadLocation(helper.GetEnv("TZ", "Europe/Berlin"))
	if err != nil {
		log.Println("Error loading location", err)
		loc = time.Local
	}

	dateFrom, err := time.ParseInLocation("2006-01-02", r.FormValue("date_from"), loc)
	if err != nil {
		log.Println("Error parsing date_from input for absence", err)
		return err
	}

	dateTo, err := time.ParseInLocation("2006-01-02", r.FormValue("date_to"), loc)
	if err != nil {
		log.Println("Error parsing date_to input for absence", err)
		return err
	}

	absenceTypeId, err := strconv.Atoi(r.FormValue("aw_type"))
	if err != nil {
		log.Println("Error parsing aw_type", err)
		return err
	}

	absenceId, err := strconv.Atoi(r.FormValue("aw_id"))
	if err != nil && r.FormValue("aw_id") == "" {
		absenceId = 0
	} else if err != nil {
		log.Println("Error parsing aw_id", err)
		return err
	}

	absenceType, err := models.GetAbsenceTypeById(int8(absenceTypeId))
	if err != nil {
		log.Println("No matching absence type found!")
		return err
	}

	newAbsence := models.Absence{DateFrom: dateFrom, DateTo: dateTo, AbwesenheitTyp: absenceType}

	absence, err := models.GetAbsenceById(absenceId)
	if err == sql.ErrNoRows {
		err = nil
		log.Println("Absence not found creating new!")

		user, err := models.GetUserFromSession(Session, r.Context())
		if err != nil {
			log.Println("No user found!", err)
			return err
		}
		newAbsence.CardUID = user.CardUID
		newAbsence.Insert()
	}
	if err != nil {
		log.Println("Cannot get Absence for id: ", absenceId, err)
		return err
	}
	if r.FormValue("action") == "delete" {
		log.Println("Deleting Absence!", "Not implemented")
		// TODO
		//absence.Delete()
		return nil
	}

	if absence.Update(newAbsence) {
		err = absence.Save()
		if err != nil {
			log.Println("Error saving updated absence!", err)
			return err
		}
	}
	return nil

}

func createAbsence(absenceType int, user models.User, loc *time.Location, r *http.Request) {
	absenceDate, err := time.ParseInLocation("2006-01-02", r.FormValue("date"), loc)
	if err != nil {
		log.Println("Cannot get date from input! Skipping absence creation", err)
		return
	}

	absence, err := models.NewAbsence(user.CardUID, absenceType, absenceDate)
	if err != nil {
		log.Println("Error creating absence!", err)
		return
	}
	err = absence.Insert()
	if err != nil {
		log.Println("Error inserting absence!", err)
		return
	}
}