package main

import (
	"context"
	"fmt"
	"log"
	"net/http"
	"runtime/debug"
	"strings"

	"git.aiterp.net/rpdata/api/database"
	"git.aiterp.net/rpdata/api/graph2"
	"git.aiterp.net/rpdata/api/internal/auth"
	"git.aiterp.net/rpdata/api/internal/config"
	"git.aiterp.net/rpdata/api/internal/instrumentation"
	"git.aiterp.net/rpdata/api/internal/loader"
	"git.aiterp.net/rpdata/api/internal/store"
	"git.aiterp.net/rpdata/api/models"
	"git.aiterp.net/rpdata/api/services"
	"github.com/99designs/gqlgen/handler"
	"github.com/prometheus/client_golang/prometheus/promhttp"
)

func main() {
	err := store.Init()
	if err != nil {
		log.Fatalln("Failed to init store:", err)
	}

	db, err := database.Init(config.Global().Database)
	if err != nil {
		log.Fatalln("Failed to init db:", err)
	}
	defer db.Close(context.Background())
	serviceBundle := services.NewBundle(db)

	instrumentation.Register()

	http.Handle("/", handler.Playground("RPData API", "/graphql"))
	http.Handle("/graphql", queryHandler(serviceBundle))

	http.Handle("/metrics", promhttp.Handler())

	go func() {
		err := serviceBundle.Logs.RefreshAllLogCharacters(context.Background())
		if err != nil {
			log.Println(err)
		}

		log.Println("Characters updated")
	}()

	go logListedChanges(serviceBundle.Changes)

	log.Fatal(http.ListenAndServe(":8081", nil))
}

func logListedChanges(changes *services.ChangeService) {
	sub := changes.Subscribe(context.Background(), models.ChangeFilter{})

	for change := range sub {
		log.Printf("Change: Author=%#+v Model=%#+v Op=%#+v", change.Author, change.Model, change.Op)
		for _, object := range change.Objects() {
			switch object := object.(type) {
			case models.Log:
				log.Printf("\tLog: %s (%s)", object.ID, object.ShortID)
			case models.Character:
				log.Printf("\tCharacter: %s", object.ID)
			case models.Channel:
				log.Printf("\tChannel: %s", object.Name)
			case models.Post:
				log.Printf("\tPost: %s", object.ID)
			case models.Story:
				log.Printf("\tStory: %s", object.ID)
			case models.Tag:
				log.Printf("\tTag: (%s,%s)", object.Kind, object.Name)
			case models.Chapter:
				log.Printf("\tChapter: %s", object.ID)
			case models.Comment:
				log.Printf("\tComment: %s", object.ID)
			}
		}
	}

	log.Println("Change subscription closed.")
}

func queryHandler(services *services.Bundle) http.HandlerFunc {
	handler := handler.GraphQL(
		graph2.New(services),
		handler.RecoverFunc(func(ctx context.Context, err interface{}) error {
			log.Println(err)
			log.Println(string(debug.Stack()))

			return fmt.Errorf("The server failed to serve your request due to an internal error, it has been logged")
		}),
		handler.ComplexityLimit(300),
		handler.RequestMiddleware(instrumentation.RequestMiddleware()),
		handler.ResolverMiddleware(instrumentation.ResolverMiddleware()),
	)
	return func(w http.ResponseWriter, r *http.Request) {
		l := loader.New()
		r = r.WithContext(l.ToContext(r.Context()))

		// >_>
		if strings.HasPrefix(r.Header.Get("Authorization"), "Bearer of the curse") {
			w.Header().Set("X-Emerald-Herald", "Seek souls. Larger, more powerful souls.")
			w.Header().Add("X-Emerald-Herald", "Seek the king, that is the only way.")
			w.Header().Add("X-Emerald-Herald", "Lest this land swallow you whole... As it has so many others.")
		}

		r = auth.RequestWithToken(r)

		handler.ServeHTTP(w, r)
	}
}