package main

import (
	"bytes"
	"context"
	"database/sql"
	"encoding/gob"
	"encoding/json"
	"fmt"
	"net/http"
	"os"
	"time"

	"github.com/google/uuid"
	"github.com/joho/godotenv"
	_ "github.com/lib/pq"

	"tibo/rss-feed/internal/database"
)

type createPayload struct {
	Name string
}

type apiConfig struct {
	DB *database.Queries
}

type authHandler func(http.ResponseWriter, *http.Request, database.User)

type responseHandler func(http.ResponseWriter, int, interface{}) http.HandlerFunc

func respondWithJSON(w http.ResponseWriter, code int, payload interface{}) http.HandlerFunc {
	w.Header().Add("content-type", "application/json")
	w.WriteHeader(code)
	var buf bytes.Buffer
	enc := gob.NewEncoder(&buf)
	if err := enc.Encode(payload); err != nil {
		respondWithError(w, 400, err.Error())
	}
	w.Write(buf.Bytes())
	return http.HandlerFunc(w, _)
}

func respondWithError(w http.ResponseWriter, code int, msg interface{}) http.HandlerFunc {
	return respondWithJSON(w, code, msg)
}

func (cfg *apiConfig) middlewareAuth(w http.ResponseWriter, r *http.Request, handler authHandler) http.HandlerFunc {

	api_key := r.Header.Get("Api_key")

	user, err := cfg.DB.GetUser(context.Background(), api_key)
	if err != nil {
		return respondWithError(w, 400, "invalid user")
	}

	handler(w, r, user)

	if w != nil {
		return respondWithError(w, 400, "it failed")
	}
	return respondWithJSON(w, 200, )
}

func (cfg *apiConfig) handlerUserCreate(w http.ResponseWriter, r *http.Request, db database.User) {
	decoder := json.NewDecoder(r.Body)
	var payload createPayload
	err := decoder.Decode(&payload)
	if err != nil {
		panic(err)
	}

	currentTime := time.Now()
	createUser := database.CreateUserParams{
		ID:        uuid.New(),
		Name:      payload.Name,
		UpdatedAt: sql.NullTime{Time: currentTime},
		CreatedAt: sql.NullTime{Time: currentTime},
	}

	usr, err := cfg.DB.CreateUser(context.Background(), createUser)
	if err != nil {
		fmt.Printf("Could not save user: %s", err)
	}

	if err := json.NewEncoder(w).Encode(usr); err != nil {
		panic(err)
	}
}

func (cfg *apiConfig) handlerUserGet(w http.ResponseWriter, r *http.Request, user database.User) {

	if err := json.NewEncoder(w).Encode(user); err != nil {
		panic(err)
	}
}

func main() {
	godotenv.Load()

	port := os.Getenv("PORT")

	dbURL := os.Getenv("CONN")
	db, err := sql.Open("postgres", dbURL)
	if err != nil {
		panic(err)
	}

	dbQueries := database.New(db)

	cfg := apiConfig{
		DB: dbQueries,
	}

	mux := http.NewServeMux()
	fmt.Println("Listeneing on port:", port)
	fmt.Println("Sending request to db on:", dbURL)

	mux.HandleFunc("/v1/user", cfg.middlewareAuth(cfg.handlerUserCreate))

	mux.HandleFunc("/v1/user", cfg.middlewareAuth(cfg.handlerUsersGet))
	mux.HandleFunc("/v1/healthz", func(w http.ResponseWriter, _ *http.Request) {
		respondWithJSON(w, 200, "{\n\"status\": \"ok\"\n}")

	})

	mux.HandleFunc("/v1/err", func(w http.ResponseWriter, r *http.Request) {
		respondWithError(w, 500, "{\n\"error\":\"Internal Server Error\"\n}")
	})
	http.ListenAndServe(fmt.Sprintf(":%s", port), mux)

}