package main

import (
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"

	"github.com/go-logr/logr"

	"edge-infra.dev/pkg/edge/api/middleware"
	"edge-infra.dev/pkg/lib/fog"
)

var secret = os.Getenv("APP_SECRET")

const (
	validUsername string = "testValidUser1"
	email         string = "testValidUser1@test.com"
	organization  string = "testOrganization"
	fakeToken     string = "abcd.efgh.ijkl"
	authProvider  string = "bsl"
)

func main() {
	logger := fog.New()
	logger.Info("Starting server")

	http.HandleFunc("/api/v2", graphQLHandler(logger))
	server := &http.Server{
		Addr:         "0.0.0.0:8080",
		Handler:      nil,
		ReadTimeout:  5 * time.Second,
		WriteTimeout: 10 * time.Second,
		IdleTimeout:  15 * time.Second,
	}

	if err := server.ListenAndServe(); err != nil {
		logger.Error(err, "Server error")
		os.Exit(1)
	}
}

type incomingPayload struct {
	Query     string
	Variables map[string]string
}

type outgoingPayload struct {
	Data gData `json:"data"`
}

type gData struct {
	Login login `json:"login"`
}

type login struct {
	Banners []banner `json:"banners"`
	Token   string   `json:"token"`
}

type banner struct {
	BannerEdgeID string `json:"bannerEdgeID"`
}

func graphQLHandler(log logr.Logger) func(w http.ResponseWriter, r *http.Request) {
	return func(w http.ResponseWriter, r *http.Request) {
		data, err := io.ReadAll(r.Body)
		if err != nil {
			log.Error(err, "error reading body")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		var body incomingPayload
		err = json.Unmarshal(data, &body)
		if err != nil {
			log.Error(err, "error unmarshaling json")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		username, ok := body.Variables["username"]
		if !ok {
			log.Error(fmt.Errorf("no username"), "Missing username")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}
		if username != validUsername {
			log.Error(fmt.Errorf("unexpected username: %s", username), "Unexpected username")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		token, err := middleware.CreateToken(
			validUsername,
			email,
			organization,
			secret,
			// role has to have EDGE_ prefix in order to be saved to session
			[]string{"EDGE_ADMIN"},
			fakeToken,
			authProvider,
			"",
		)
		if err != nil {
			log.Error(err, "Error creating token")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		log.Info("Created new token", "secret", secret, "token", token)

		resp := outgoingPayload{
			Data: gData{
				Login: login{
					Banners: []banner{
						{BannerEdgeID: "3cf00a00-d06b-40c7-859c-fbddfdeb1177"},
					},
					Token: token,
				},
			},
		}

		out, err := json.Marshal(resp)
		if err != nil {
			log.Error(err, "Error marshalling response data")
			w.WriteHeader(http.StatusInternalServerError)
			return
		}

		w.WriteHeader(http.StatusOK)
		w.Header().Set("content-type", "application/json")
		_, err = w.Write(out)
		if err != nil {
			log.Error(err, "error writing response")
			return
		}
	}
}