// Package handler provides the HTTP handler for the marka server
package handler

import (
	"errors"
	"net/http"
	"time"

	"git.max-richter.dev/max/marka/parser"
	"git.max-richter.dev/max/marka/server-new/internal/adapters"
)

type ResponseItem struct {
	Name    string    `json:"name"`
	Content any       `json:"content,omitempty"`
	Type    string    `json:"type,omitempty"`
	IsDir   bool      `json:"isDir"`
	Size    int64     `json:"size,omitempty"`
	ModTime time.Time `json:"modTime"`
}

type Handler struct {
	adapter adapters.FileAdapter
}

func (h *Handler) get(w http.ResponseWriter, target string) {
	fsEntry, err := h.adapter.Read(target)
	if err != nil {
		writeError(w, 500, err)
		return
	}

	if fsEntry.File != nil {

		if fsEntry.File.Content != nil && fsEntry.File.Type == "application/markdown" {
			data, err := parser.ParseFile(string(fsEntry.File.Content))
			if err != nil {
				writeError(w, 500, err)
				return
			}

			res := ResponseItem{
				Name:    fsEntry.File.Name,
				Type:    fsEntry.File.Type,
				Content: data,
				IsDir:   false,
				Size:    int64(len(fsEntry.File.Content)),
				ModTime: fsEntry.File.ModTime,
			}

			writeJSON(w, 200, res)
			return
		}

		writeFile(w, fsEntry.File)
		return
	}

	if fsEntry.Dir != nil {
		res := ResponseItem{
			Name:    fsEntry.Dir.Name,
			Content: fsEntry.Dir.Files,
			IsDir:   true,
			ModTime: fsEntry.Dir.ModTime,
		}
		writeJSON(w, 200, res)
		return
	}
}

func (h *Handler) post(w http.ResponseWriter, target string) {
}

func (h *Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	reqPath := r.URL.Path
	if reqPath == "" {
		reqPath = "/"
	}

	target := cleanURLLike(reqPath)

	switch r.Method {
	case http.MethodGet:
		h.get(w, target)
	case http.MethodPost:
		h.post(w, target)
	default:
		writeError(w, http.StatusMethodNotAllowed, errors.New("method not allowed"))
	}
}

func NewHandler(adapter adapters.FileAdapter) http.Handler {
	return &Handler{
		adapter: adapter,
	}
}