package auth

import (
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"net/http"
	"strings"

	"astraltech.xyz/calendar/v2/caldav"
	"astraltech.xyz/calendar/v2/webserver"
	ics "github.com/arran4/golang-ical"
	"golang.org/x/oauth2"
)

var TestTokenStore TokenStore

func SetAuth() {
	TestTokenStore = TokenStore{filePath: "token.json"}
}

func generateState() (string, error) {
	b := make([]byte, 32)
	if _, err := rand.Read(b); err != nil {
		return "", err
	}
	return base64.RawURLEncoding.EncodeToString(b), nil
}

func HandlePasswordAuth(authData webserver.PasswordAuthData) bool {
	calDavData := caldav.GetCalDAVData(authData.Username, authData.Password)

	fmt.Printf("Users display name: %s\n", calDavData.DisplayName)
	fmt.Printf("Calandar Count: %d\n", len(calDavData.Calandars))
	for i := range len(calDavData.Calandars) {
		calDavData.Calandars[i] = caldav.GetCalendarData(calDavData.Calandars[i], authData.Username, authData.Password)

		fmt.Printf("Cal %d is named %s\n", i, calDavData.Calandars[i].DisplayName)
		fmt.Printf("\tLink to cal: %s\n", calDavData.Calandars[i].Link)
		fmt.Printf("\tEvent count: %d\n", len(calDavData.Calandars[i].Events))
		for j := range len(calDavData.Calandars[i].Events) {
			cal, err := ics.ParseCalendar(strings.NewReader(calDavData.Calandars[i].Events[j].CalData))
			if err != nil {
				fmt.Print(err.Error())
			}
			events := cal.Events()
			for k := range len(events) {
				name := events[k].GetProperty(ics.ComponentProperty(ics.PropertySummary)).Value
				start, _ := events[k].GetStartAt()
				end, _ := events[k].GetEndAt()
				time := end.Sub(start)
				fmt.Printf("\t\tEvent name: %s\n", name)
				fmt.Printf("\t\t\tEvent start date: %s\n", end.UTC().String())
				fmt.Printf("\t\t\tEvent length date: %s\n", time.String())

			}
		}
	}
	return false
}

func HandleOAuth(authData webserver.OAuthAuthData) bool {
	state, err := generateState()
	if err != nil {
		http.Error(*authData.ResponseWriter, "Failed to generate state", http.StatusInternalServerError)
		return false
	}
	verifier := oauth2.GenerateVerifier()

	http.SetCookie(*authData.ResponseWriter, &http.Cookie{
		Name:     "oauth_state",
		Value:    state,
		Path:     "/",
		MaxAge:   300,
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
	})

	http.SetCookie(*authData.ResponseWriter, &http.Cookie{
		Name:     "pkce_verifier",
		Value:    verifier,
		Path:     "/",
		HttpOnly: true,
		SameSite: http.SameSiteLaxMode,
	})

	url := DefaultProvider.Config.AuthCodeURL(
		state,
		oauth2.S256ChallengeOption(verifier),
	)
	http.Redirect(*authData.ResponseWriter, authData.Request, url, http.StatusFound)

	return false
}

func HandleAuthRequest(authType webserver.AuthStyle, authData webserver.AuthData) bool {
	if authType == webserver.AuthStylePassword {
		passwordAuthData, _ := authData.(webserver.PasswordAuthData)
		return HandlePasswordAuth(passwordAuthData)
	}

	if authType == webserver.AuthStyleOAuth {
		passwordAuthData, _ := authData.(webserver.OAuthAuthData)
		return HandleOAuth(passwordAuthData)
	}

	return false
}