package httpapi

import (
	"encoding/json"
	"errors"
	"net/http"
	"strings"

	"github.com/easyai/easyai-ai-gateway/apps/api/internal/store"
)

func (s *Server) listCatalogProviders(w http.ResponseWriter, r *http.Request) {
	items, err := s.store.ListCatalogProviders(r.Context())
	if err != nil {
		s.logger.Error("list catalog providers failed", "error", err)
		writeError(w, http.StatusInternalServerError, "list catalog providers failed")
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"items": items})
}

func (s *Server) createCatalogProvider(w http.ResponseWriter, r *http.Request) {
	var input store.CatalogProviderInput
	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
		writeError(w, http.StatusBadRequest, "invalid json body")
		return
	}
	if strings.TrimSpace(input.ProviderKey) == "" || strings.TrimSpace(input.DisplayName) == "" {
		writeError(w, http.StatusBadRequest, "providerKey and displayName are required")
		return
	}
	item, err := s.store.CreateCatalogProvider(r.Context(), input)
	if err != nil {
		if store.IsUniqueViolation(err) {
			writeError(w, http.StatusConflict, "provider key or code already exists")
			return
		}
		s.logger.Error("create catalog provider failed", "error", err)
		writeError(w, http.StatusInternalServerError, "create catalog provider failed")
		return
	}
	writeJSON(w, http.StatusCreated, item)
}

func (s *Server) updateCatalogProvider(w http.ResponseWriter, r *http.Request) {
	var input store.CatalogProviderInput
	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
		writeError(w, http.StatusBadRequest, "invalid json body")
		return
	}
	if strings.TrimSpace(input.ProviderKey) == "" || strings.TrimSpace(input.DisplayName) == "" {
		writeError(w, http.StatusBadRequest, "providerKey and displayName are required")
		return
	}
	item, err := s.store.UpdateCatalogProvider(r.Context(), r.PathValue("providerID"), input)
	if err != nil {
		if store.IsNotFound(err) {
			writeError(w, http.StatusNotFound, "catalog provider not found")
			return
		}
		if store.IsUniqueViolation(err) {
			writeError(w, http.StatusConflict, "provider key or code already exists")
			return
		}
		s.logger.Error("update catalog provider failed", "error", err)
		writeError(w, http.StatusInternalServerError, "update catalog provider failed")
		return
	}
	writeJSON(w, http.StatusOK, item)
}

func (s *Server) deleteCatalogProvider(w http.ResponseWriter, r *http.Request) {
	if err := s.store.DeleteCatalogProvider(r.Context(), r.PathValue("providerID")); err != nil {
		if store.IsNotFound(err) {
			writeError(w, http.StatusNotFound, "catalog provider not found")
			return
		}
		s.logger.Error("delete catalog provider failed", "error", err)
		writeError(w, http.StatusInternalServerError, "delete catalog provider failed")
		return
	}
	w.WriteHeader(http.StatusNoContent)
}

func (s *Server) listBaseModels(w http.ResponseWriter, r *http.Request) {
	items, err := s.store.ListBaseModels(r.Context())
	if err != nil {
		s.logger.Error("list base models failed", "error", err)
		writeError(w, http.StatusInternalServerError, "list base models failed")
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"items": items})
}

func (s *Server) createBaseModel(w http.ResponseWriter, r *http.Request) {
	var input store.BaseModelInput
	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
		writeError(w, http.StatusBadRequest, "invalid json body")
		return
	}
	if !validBaseModelInput(input) {
		writeError(w, http.StatusBadRequest, "providerKey, providerModelName and modelType are required")
		return
	}
	item, err := s.store.CreateBaseModel(r.Context(), input)
	if err != nil {
		if store.IsUniqueViolation(err) {
			writeError(w, http.StatusConflict, "canonical model key already exists")
			return
		}
		s.logger.Error("create base model failed", "error", err)
		writeError(w, http.StatusInternalServerError, "create base model failed")
		return
	}
	writeJSON(w, http.StatusCreated, item)
}

func (s *Server) updateBaseModel(w http.ResponseWriter, r *http.Request) {
	var input store.BaseModelInput
	if err := json.NewDecoder(r.Body).Decode(&input); err != nil {
		writeError(w, http.StatusBadRequest, "invalid json body")
		return
	}
	if !validBaseModelInput(input) {
		writeError(w, http.StatusBadRequest, "providerKey, providerModelName and modelType are required")
		return
	}
	item, err := s.store.UpdateBaseModel(r.Context(), r.PathValue("baseModelID"), input)
	if err != nil {
		if store.IsNotFound(err) {
			writeError(w, http.StatusNotFound, "base model not found")
			return
		}
		if store.IsUniqueViolation(err) {
			writeError(w, http.StatusConflict, "canonical model key already exists")
			return
		}
		s.logger.Error("update base model failed", "error", err)
		writeError(w, http.StatusInternalServerError, "update base model failed")
		return
	}
	writeJSON(w, http.StatusOK, item)
}

func (s *Server) resetBaseModel(w http.ResponseWriter, r *http.Request) {
	item, err := s.store.ResetBaseModelToDefault(r.Context(), r.PathValue("baseModelID"))
	if err != nil {
		if store.IsNotFound(err) {
			writeError(w, http.StatusNotFound, "base model not found")
			return
		}
		if errors.Is(err, store.ErrProtectedDefault) {
			writeError(w, http.StatusConflict, "base model has no system default snapshot")
			return
		}
		s.logger.Error("reset base model failed", "error", err)
		writeError(w, http.StatusInternalServerError, "reset base model failed")
		return
	}
	writeJSON(w, http.StatusOK, item)
}

func (s *Server) resetAllBaseModels(w http.ResponseWriter, r *http.Request) {
	items, err := s.store.ResetAllBaseModelsToDefault(r.Context())
	if err != nil {
		s.logger.Error("reset all base models failed", "error", err)
		writeError(w, http.StatusInternalServerError, "reset all base models failed")
		return
	}
	writeJSON(w, http.StatusOK, map[string]any{"items": items})
}

func (s *Server) deleteBaseModel(w http.ResponseWriter, r *http.Request) {
	if err := s.store.DeleteBaseModel(r.Context(), r.PathValue("baseModelID")); err != nil {
		if store.IsNotFound(err) {
			writeError(w, http.StatusNotFound, "base model not found")
			return
		}
		s.logger.Error("delete base model failed", "error", err)
		writeError(w, http.StatusInternalServerError, "delete base model failed")
		return
	}
	w.WriteHeader(http.StatusNoContent)
}

func validBaseModelInput(input store.BaseModelInput) bool {
	return strings.TrimSpace(input.ProviderKey) != "" &&
		strings.TrimSpace(input.ProviderModelName) != "" &&
		len(input.ModelType) > 0
}