package org

import (
	"net/http"
	"strings"

	"github.com/tidbcloud/AgentTeam/internal/api"
	"github.com/tidbcloud/AgentTeam/internal/api/dto"
	"github.com/tidbcloud/AgentTeam/internal/api/dto/converter"
	"github.com/tidbcloud/AgentTeam/internal/store/organization"

	"github.com/gin-gonic/gin"
)

// TokensList handles GET /api/v1/orgs/:orgId/providers/:providerId/tokens.
func (handler *ProviderHandler) TokensList(ctx *gin.Context) {
	authenticated, ok := api.AuthenticatedUserFromContext(ctx)
	if !ok {
		api.Error(ctx, http.StatusUnauthorized, "Unauthorized")
		return
	}
	orgs, ok := handler.organizationProvider()
	if !ok {
		api.Error(ctx, http.StatusNotFound, "Organization provider not installed")
		return
	}
	organizationID := strings.TrimSpace(ctx.Param("orgId"))
	providerID := strings.TrimSpace(ctx.Param("providerId"))
	if organizationID == "" || providerID == "" {
		api.Error(ctx, http.StatusBadRequest, "Invalid request")
		return
	}
	items, err := orgs.ListOrganizationProviderTokensForUser(ctx.Request.Context(), authenticated.User.ID, organizationID, providerID)
	if err != nil {
		api.StoreError(ctx, err)
		return
	}
	ctx.JSON(http.StatusOK, converter.ToOrgProviderTokenViews(items))
}

// TokenCreate handles POST /api/v1/orgs/:orgId/providers/:providerId/tokens.
func (handler *ProviderHandler) TokenCreate(ctx *gin.Context) {
	authenticated, ok := api.AuthenticatedUserFromContext(ctx)
	if !ok {
		api.Error(ctx, http.StatusUnauthorized, "Unauthorized")
		return
	}
	orgs, ok := handler.organizationProvider()
	if !ok {
		api.Error(ctx, http.StatusNotFound, "Organization provider not installed")
		return
	}
	organizationID := strings.TrimSpace(ctx.Param("orgId"))
	providerID := strings.TrimSpace(ctx.Param("providerId"))
	if organizationID == "" || providerID == "" {
		api.Error(ctx, http.StatusBadRequest, "Invalid request")
		return
	}
	var request dto.OrganizationProviderTokenCreateRequest
	if err := ctx.ShouldBindJSON(&request); err != nil {
		api.Error(ctx, http.StatusBadRequest, "Invalid request body")
		return
	}
	item, err := orgs.CreateOrganizationProviderTokenForUser(ctx.Request.Context(), authenticated.User.ID, organizationID, providerID, organization.CreateOrganizationProviderTokenParams{
		Label: request.Label,
		Token: request.Token,
		Config: organization.OrganizationProviderTokenConfig{
			Role:                request.Config.Role,
			BaseURL:             request.Config.BaseURL,
			Mode:                request.Config.Mode,
			BackendName:         request.Config.BackendName,
			BackendID:           request.Config.BackendID,
			Active:              request.Config.Active,
			Weight:              request.Config.Weight,
			WeightDiffThreshold: request.Config.WeightDiffThreshold,
			AdaptiveWeights:     request.Config.AdaptiveWeights,
			RequiresOAuthBeta:   request.Config.RequiresOAuthBeta,
			AllowedAPIKeys:      request.Config.AllowedAPIKeys,
			CustomPrompt:        request.Config.CustomPrompt,
			CustomPromptModels:  request.Config.CustomPromptModels,
		},
		Secret: organization.OrganizationProviderTokenMaterial{
			Token:           request.Secret.Token,
			APIKey:          request.Secret.APIKey,
			AuthToken:       request.Secret.AuthToken,
			AuthJSONContent: request.Secret.AuthJSONContent,
		},
	})
	if err != nil {
		api.StoreError(ctx, err)
		return
	}
	if err := handler.refreshLLMRegistry(ctx.Request.Context()); err != nil {
		api.StoreError(ctx, err)
		return
	}
	ctx.JSON(http.StatusOK, converter.ToOrgProviderTokenView(item))
}

// TokenDelete handles DELETE /api/v1/orgs/:orgId/providers/:providerId/tokens/:tokenId.
func (handler *ProviderHandler) TokenDelete(ctx *gin.Context) {
	authenticated, ok := api.AuthenticatedUserFromContext(ctx)
	if !ok {
		api.Error(ctx, http.StatusUnauthorized, "Unauthorized")
		return
	}
	orgs, ok := handler.organizationProvider()
	if !ok {
		api.Error(ctx, http.StatusNotFound, "Organization provider not installed")
		return
	}
	organizationID := strings.TrimSpace(ctx.Param("orgId"))
	providerID := strings.TrimSpace(ctx.Param("providerId"))
	tokenID := strings.TrimSpace(ctx.Param("tokenId"))
	if organizationID == "" || providerID == "" || tokenID == "" {
		api.Error(ctx, http.StatusBadRequest, "Invalid request")
		return
	}
	if err := orgs.DeleteOrganizationProviderTokenForUser(ctx.Request.Context(), authenticated.User.ID, organizationID, providerID, tokenID); err != nil {
		api.StoreError(ctx, err)
		return
	}
	if err := handler.refreshLLMRegistry(ctx.Request.Context()); err != nil {
		api.StoreError(ctx, err)
		return
	}
	ctx.JSON(http.StatusOK, dto.EmptyResponse{})
}