package controller

import (
	"context"
	"encoding/json"
	"log/slog"
	"net/http"

	"github.com/AFASystems/presence/internal/pkg/api/response"
	"github.com/AFASystems/presence/internal/pkg/model"
	"github.com/AFASystems/presence/internal/pkg/service"
	"github.com/AFASystems/presence/internal/pkg/validation"
	"github.com/gorilla/mux"
	"github.com/segmentio/kafka-go"
	"gorm.io/gorm"
)

func ParserAddController(db *gorm.DB, writer *kafka.Writer, context context.Context) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var config model.Config
		if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
			response.BadRequest(w, "invalid request body")
			return
		}
		if err := validation.Struct(&config); err != nil {
			response.BadRequest(w, err.Error())
			return
		}

		if err := db.WithContext(context).Create(&config).Error; err != nil {
			response.InternalError(w, "failed to create parser config", err)
			return
		}

		kp := model.KafkaParser{
			ID:     "add",
			Config: config,
		}

		if err := service.SendParserConfig(kp, writer, context); err != nil {
			slog.Error("failed to send parser config to Kafka", "err", err)
			response.InternalError(w, "failed to publish parser config", err)
			return
		}

		response.JSON(w, http.StatusCreated, map[string]string{"status": "created"})
	}
}

func ParserListController(db *gorm.DB, context context.Context) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		var configs []model.Config
		if err := db.WithContext(context).Find(&configs).Error; err != nil {
			response.InternalError(w, "failed to list parser configs", err)
			return
		}
		response.JSON(w, http.StatusOK, configs)
	}
}

func ParserDeleteController(db *gorm.DB, writer *kafka.Writer, context context.Context) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		id := mux.Vars(r)["id"]
		res := db.WithContext(context).Delete(&model.Config{}, "name = ?", id)
		if res.RowsAffected == 0 {
			response.NotFound(w, "parser config not found")
			return
		}
		if res.Error != nil {
			response.InternalError(w, "failed to delete parser config", res.Error)
			return
		}

		kp := model.KafkaParser{
			ID:   "delete",
			Name: id,
		}

		if err := service.SendParserConfig(kp, writer, context); err != nil {
			slog.Error("failed to send parser config to Kafka", "err", err)
			response.InternalError(w, "failed to publish parser config deletion", err)
			return
		}

		response.JSON(w, http.StatusOK, map[string]string{"status": "deleted"})
	}
}

func ParserUpdateController(db *gorm.DB, writer *kafka.Writer, context context.Context) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		id := mux.Vars(r)["id"]

		if err := db.WithContext(context).First(&model.Config{}, "name = ?", id).Error; err != nil {
			response.NotFound(w, "parser config not found")
			return
		}

		var config model.Config
		if err := json.NewDecoder(r.Body).Decode(&config); err != nil {
			response.BadRequest(w, "invalid request body")
			return
		}
		if err := validation.Struct(&config); err != nil {
			response.BadRequest(w, err.Error())
			return
		}

		if err := db.WithContext(context).Save(&config).Error; err != nil {
			response.InternalError(w, "failed to update parser config", err)
			return
		}

		kp := model.KafkaParser{
			ID:     "update",
			Name:   config.Name,
			Config: config,
		}

		if err := service.SendParserConfig(kp, writer, context); err != nil {
			slog.Error("failed to send parser config to Kafka", "err", err)
			response.InternalError(w, "failed to publish parser config update", err)
			return
		}

		response.JSON(w, http.StatusOK, map[string]string{"status": "updated"})
	}
}