package handlers

import "errors"
import "fmt"
import "net/http"

import "codit/internal/db"
import "codit/internal/models"

func (api *API) ListBoardFieldValues(w http.ResponseWriter, r *http.Request, params map[string]string) {
	var values []models.BoardFieldValue
	var err error

	if !api.requireBoardRole(w, r, params["boardId"], models.RoleViewer) {
		return
	}
	values, err = api.store(r).ListBoardFieldValues(params["boardId"], params["field"])
	if err != nil {
		WriteJSONWithErrorReason(w, r, http.StatusInternalServerError, err.Error())
		return
	}
	if values == nil {
		values = []models.BoardFieldValue{}
	}
	WriteJSON(w, http.StatusOK, values)
}

type boardFieldValueRequest struct {
	Value     string `json:"value"`
	Label     string `json:"label"`
	Color     string `json:"color"`
	StartDate string `json:"start_date"`
	EndDate   string `json:"end_date"`
}

func (api *API) CreateBoardFieldValue(w http.ResponseWriter, r *http.Request, params map[string]string) {
	var req boardFieldValueRequest
	var fv models.BoardFieldValue
	var created models.BoardFieldValue
	var err error

	if !api.requireBoardRole(w, r, params["boardId"], models.RoleAdmin) {
		return
	}
	err = DecodeJSON(r, &req)
	if err != nil || req.Value == "" || req.Label == "" {
		WriteJSONWithErrorReason(w, r, http.StatusBadRequest, "value and label are required")
		return
	}
	fv = models.BoardFieldValue{
		Field:     params["field"],
		Value:     req.Value,
		Label:     req.Label,
		Color:     req.Color,
		StartDate: req.StartDate,
		EndDate:   req.EndDate,
	}
	created, err = api.store(r).CreateBoardFieldValue(r.Context(), params["boardId"], fv)
	if err != nil {
		if errors.Is(err, db.ErrBoardNotFound) {
			WriteJSONWithErrorReason(w, r, http.StatusNotFound, "board not found")
			return
		}
		WriteJSONWithErrorReason(w, r, http.StatusInternalServerError, err.Error())
		return
	}
	WriteJSON(w, http.StatusCreated, created)
}

func (api *API) UpdateBoardFieldValue(w http.ResponseWriter, r *http.Request, params map[string]string) {
	var req boardFieldValueRequest
	var fv models.BoardFieldValue
	var updated models.BoardFieldValue
	var err error

	if !api.requireBoardRole(w, r, params["boardId"], models.RoleAdmin) {
		return
	}
	err = DecodeJSON(r, &req)
	if err != nil || req.Label == "" {
		WriteJSONWithErrorReason(w, r, http.StatusBadRequest, "label is required")
		return
	}
	fv = models.BoardFieldValue{
		Label:     req.Label,
		Color:     req.Color,
		StartDate: req.StartDate,
		EndDate:   req.EndDate,
	}
	updated, err = api.store(r).UpdateBoardFieldValue(params["boardId"], params["valueId"], fv)
	if err != nil {
		if errors.Is(err, db.ErrFieldValueNotFound) {
			WriteJSONWithErrorReason(w, r, http.StatusNotFound, "field value not found")
			return
		}
		WriteJSONWithErrorReason(w, r, http.StatusInternalServerError, err.Error())
		return
	}
	WriteJSON(w, http.StatusOK, updated)
}

func (api *API) ReorderBoardFieldValues(w http.ResponseWriter, r *http.Request, params map[string]string) {
	var req struct {
		IDs []string `json:"ids"`
	}
	var values []models.BoardFieldValue
	var err error

	if !api.requireBoardRole(w, r, params["boardId"], models.RoleAdmin) {
		return
	}
	err = DecodeJSON(r, &req)
	if err != nil || len(req.IDs) == 0 {
		WriteJSONWithErrorReason(w, r, http.StatusBadRequest, "ids are required")
		return
	}
	values, err = api.store(r).ReorderBoardFieldValues(r.Context(), params["boardId"], params["field"], req.IDs)
	if err != nil {
		if errors.Is(err, db.ErrBoardNotFound) {
			WriteJSONWithErrorReason(w, r, http.StatusNotFound, "board not found")
			return
		}
		WriteJSONWithErrorReason(w, r, http.StatusInternalServerError, err.Error())
		return
	}
	if values == nil {
		values = []models.BoardFieldValue{}
	}
	WriteJSON(w, http.StatusOK, values)
}

func (api *API) DeleteBoardFieldValue(w http.ResponseWriter, r *http.Request, params map[string]string) {
	var err error

	if !api.requireBoardRole(w, r, params["boardId"], models.RoleAdmin) {
		return
	}
	err = api.store(r).DeleteBoardFieldValue(r.Context(), params["boardId"], params["valueId"])
	if err != nil {
		if errors.Is(err, db.ErrFieldValueNotFound) {
			WriteJSONWithErrorReason(w, r, http.StatusNotFound, "field value not found")
			return
		}
		if errors.Is(err, db.ErrFieldValueInUse) {
			WriteJSONWithErrorReason(w, r, http.StatusConflict, fmt.Sprintf("%s", err.Error()))
			return
		}
		WriteJSONWithErrorReason(w, r, http.StatusInternalServerError, err.Error())
		return
	}
	w.WriteHeader(http.StatusNoContent)
}