handler.go

package handler

import (
	"backend/internal/api/request"
	"backend/internal/api/response"
	"backend/internal/api/validator"
	"backend/internal/db"
	"backend/internal/middleware/auth"
	"context"
	"fmt"
	"log/slog"
	"net/http"
)

type Service interface {
	GetNoteById(ctx context.Context, noteID int) (db.Note, error)
	GetNoteList(ctx context.Context) ([]db.Note, error)
	UpdateNodeById(ctx context.Context, note request.UpdatedNote, id int) error
	DelNoteById(ctx context.Context, noteID int) error
	CreateNote(ctx context.Context, clerkid string) (int, error)
}

type Handler struct {
	Service Service
	Logger  *slog.Logger
}

func check(err error) {
	if err != nil {
		panic(err)
	}
}

func (db *Handler) NoteHandler(w http.ResponseWriter, r *http.Request) {
	db.Logger.Debug("NoteHandler called")

	id, httperr := validator.GetNoteValidator(r)
	if httperr != nil {
		validator.WriteError(w, httperr)
		return
	}

	note, err := db.Service.GetNoteById(r.Context(), id)
	response.WriteJSONResponse(w, http.StatusOK, note)
	check(err)
}

func (db *Handler) NoteListHandler(w http.ResponseWriter, r *http.Request) {
	db.Logger.Debug("NoteListHandler called")

	httperr := validator.GetNotelistValidator(r)
	if httperr != nil {
		validator.WriteError(w, httperr)
		return
	}

	notelist, err := db.Service.GetNoteList(r.Context())
	response.WriteJSONResponse(w, http.StatusOK, notelist)
	check(err)
}

func (h *Handler) CreateNodeHandler(w http.ResponseWriter, r *http.Request) {
	h.Logger.Debug("CreateNodeHandler called")

	httperr := validator.CreateNoteValidator(r)
	if httperr != nil {
		validator.WriteError(w, httperr)
		return
	}

	clerkID, ok := auth.UserIDFromContext(r.Context())
	if !ok {
		http.Error(w, "unauthorized", http.StatusUnauthorized)
		return
	}

	noteID, err := h.Service.CreateNote(r.Context(), clerkID)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
}

func (db *Handler) ImportNotesHandler(w http.ResponseWriter, r *http.Request) {
	db.Logger.Debug("ImportNotesHandler called")

	httperr := validator.ImportNotesValidator(r)
	if httperr != nil {
		validator.WriteError(w, httperr)
		return
	}

	clerkID, ok := auth.UserIDFromContext(r.Context())
	if !ok {
		http.Error(w, "unauthorized", http.StatusUnauthorized)
		return
	}

	note, err := request.UpdateNoteparser(r)
	if err != nil {
		http.Error(w, "invalid request body", http.StatusBadRequest)
		return
	}

	noteID, err := db.Service.CreateNote(r.Context(), clerkID)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	if err := db.Service.UpdateNodeById(r.Context(), note, noteID); err != nil {
		if deleteErr := db.Service.DelNoteById(r.Context(), noteID); deleteErr != nil {
			db.Logger.Error("failed to delete imported note after update failure", "note_id", noteID, "error", deleteErr)
		}

		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	response.WriteResponse(w, http.StatusAccepted, fmt.Sprintf("%d", noteID))
}

func (db *Handler) UpdateNoteHandler(w http.ResponseWriter, r *http.Request) {
	db.Logger.Debug("UpdateNoteHandler called")

	id, httperr := validator.UpdateNoteValidator(r)
	if httperr != nil {
		validator.WriteError(w, httperr)
		return
	}

	note, err := request.UpdateNoteparser(r)
	if err != nil {
		http.Error(w, "invalid request body", http.StatusBadRequest)
		return
	}

	if err := db.Service.UpdateNodeById(r.Context(), note, id); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
}

func (db *Handler) DelNoteHandler(w http.ResponseWriter, r *http.Request) {
	db.Logger.Debug("DelNoteHandler called")

	id, httperr := validator.DeleteNoteValidator(r)
	if httperr != nil {
		validator.WriteError(w, httperr)
		return
	}

	err := db.Service.DelNoteById(r.Context(), id)
	check(err)
}