package controllers

import (
	"GoMembership/internal/constants"
	"GoMembership/internal/models"
	"GoMembership/internal/services"
	"GoMembership/internal/utils"
	"strings"

	"net/http"

	"github.com/gin-gonic/gin"

	"GoMembership/pkg/errors"
	"GoMembership/pkg/logger"
)

type MembershipController struct {
	Service        services.MembershipService
	UserController interface {
		ExtractUserFromContext(*gin.Context) (*models.User, error)
	}
}

type MembershipData struct {
	// APIKey string                   `json:"api_key"`
	Subscription models.SubscriptionModel `json:"subscription"`
}

func (mc *MembershipController) RegisterSubscription(c *gin.Context) {
	var regData MembershipData

	requestUser, err := mc.UserController.ExtractUserFromContext(c)
	if err != nil {
		utils.RespondWithError(c, err, "Error extracting user from context in subscription registrationHandler", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
		return
	}

	if !utils.HasPrivilige(requestUser, constants.Priviliges.Create) {
		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to register subscription", http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
		return
	}

	if err := c.ShouldBindJSON(&regData); err != nil {
		utils.HandleValidationError(c, err)
		return
	}

	// Register Subscription
	id, err := mc.Service.RegisterSubscription(&regData.Subscription)
	if err != nil {
		if strings.Contains(err.Error(), "UNIQUE constraint failed") {
			utils.RespondWithError(c, err, "Subscription already exists", http.StatusConflict, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.Duplicate)
		} else {
			utils.RespondWithError(c, err, "Couldn't register Membershipmodel", http.StatusInternalServerError, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.InternalServerError)
		}
		return
	}
	logger.Info.Printf("registering subscription: %+v", regData)
	c.JSON(http.StatusCreated, gin.H{
		"status": "success",
		"id":     id,
	})
}

func (mc *MembershipController) UpdateHandler(c *gin.Context) {
	var regData MembershipData

	requestUser, err := mc.UserController.ExtractUserFromContext(c)
	if err != nil {
		utils.RespondWithError(c, err, "Error extracting user from context in subscription Updatehandler", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
		return
	}

	if !utils.HasPrivilige(requestUser, constants.Priviliges.Update) {
		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to update subscription", http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
		return
	}

	if err := c.ShouldBindJSON(&regData); err != nil {
		utils.HandleValidationError(c, err)
		return
	}

	// update Subscription
	logger.Info.Printf("Updating subscription %v", regData.Subscription.Name)
	id, err := mc.Service.UpdateSubscription(&regData.Subscription)
	if err != nil {
		if strings.Contains(err.Error(), "UNIQUE constraint failed") {
			utils.RespondWithError(c, err, "Subscription already exists", http.StatusConflict, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.Duplicate)
		} else if err == errors.ErrSubscriptionNotFound {
			utils.RespondWithError(c, err, "Subscription not found", http.StatusNotFound, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.NotFound)
		} else if err == errors.ErrInvalidSubscriptionData {
			utils.RespondWithError(c, err, "Invalid subscription data", http.StatusBadRequest, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.Invalid)
		} else {
			utils.RespondWithError(c, err, "Couldn't update subscription", http.StatusInternalServerError, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.InternalServerError)
		}
		return
	}
	logger.Info.Printf("updating subscription: %+v", regData)
	c.JSON(http.StatusAccepted, gin.H{
		"status": "success",
		"id":     id,
	})
}

func (mc *MembershipController) DeleteSubscription(c *gin.Context) {
	type deleteData struct {
		Subscription struct {
			ID   uint   `json:"id"`
			Name string `json:"name"`
		} `json:"subscription"`
	}

	var data deleteData
	requestUser, err := mc.UserController.ExtractUserFromContext(c)
	if err != nil {
		utils.RespondWithError(c, err, "Error extracting user from context in subscription deleteSubscription", http.StatusBadRequest, errors.Responses.Fields.User, errors.Responses.Keys.NoAuthToken)
		return
	}

	if !utils.HasPrivilige(requestUser, constants.Priviliges.Delete) {
		utils.RespondWithError(c, errors.ErrNotAuthorized, "Not allowed to update subscription", http.StatusForbidden, errors.Responses.Fields.User, errors.Responses.Keys.Unauthorized)
		return
	}

	if err := c.ShouldBindJSON(&data); err != nil {
		utils.HandleValidationError(c, err)
		return
	}

	if err := mc.Service.DeleteSubscription(&data.Subscription.ID, &data.Subscription.Name); err != nil {
		if err == errors.ErrNoData {
			utils.RespondWithError(c, err, "Missing subscription name during deletion", http.StatusExpectationFailed, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.Invalid)
		} else if err == errors.ErrSubscriptionNotFound {
			utils.RespondWithError(c, err, "Subscription not found", http.StatusNotFound, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.NotFound)
		} else if err == errors.ErrInvalidSubscriptionData {
			utils.RespondWithError(c, err, "Invalid subscription data", http.StatusBadRequest, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.Invalid)
		} else if err == errors.ErrSubscriptionInUse {
			utils.RespondWithError(c, err, "Subscription is in use by at least one user", http.StatusExpectationFailed, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.InUse)
		} else {
			utils.RespondWithError(c, err, "Error during subscription Deletion", http.StatusInternalServerError, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.InternalServerError)
		}
		return
	}

	c.JSON(http.StatusOK, gin.H{"message": "Subscription deleted successfully"})
}

func (mc *MembershipController) GetSubscriptions(c *gin.Context) {
	subscriptions, err := mc.Service.GetSubscriptions(nil)
	if err != nil {
		utils.RespondWithError(c, err, "Error retrieving subscriptions", http.StatusInternalServerError, errors.Responses.Fields.SubscriptionModel, errors.Responses.Keys.InternalServerError)
		return
	}

	c.JSON(http.StatusOK, gin.H{
		"subscriptions": subscriptions,
	})
}