package vfs

import (
	"net/http"
	"strings"

	api "git.zzyxyz.com/zzy/zzyxyz_go_api/gen/vfs"
	"git.zzyxyz.com/zzy/zzyxyz_go_api/internal/vfs/models"
	"github.com/gin-gonic/gin"
)

// ServiceProxy 服务代理接口
type ServiceProxy interface {
	// Get 从后端服务获取数据
	Get(c *gin.Context, servicePath string, node *models.VfsNode) (any, error)

	// Create 在后端服务创建资源
	Create(c *gin.Context, servicePath string, node *models.VfsNode, data []byte) (string, error) // 返回创建的资源ID

	// Update 更新后端服务资源
	Update(c *gin.Context, servicePath string, node *models.VfsNode, data []byte) error

	// Delete 删除后端服务资源
	Delete(c *gin.Context, servicePath string, node *models.VfsNode) error

	// GetName 获取代理名称
	GetName() string
}

// ProxyEntry 代理表条目
type ProxyEntry struct {
	Name     string
	MatchExt string
	Proxy    ServiceProxy // 对应的代理实现
}

// FindProxyByServiceName 根据服务节点名称查找对应的代理
func (v *VfsImpl) FindProxyByServiceName(serviceName string) ServiceProxy {
	v.proxyMutex.RLock()
	defer v.proxyMutex.RUnlock()

	if serviceName == "" {
		return nil
	}

	// 根据服务名称匹配前缀
	for _, entry := range v.proxyTable {
		if entry.MatchExt == serviceName {
			return entry.Proxy
		}
	}

	return nil
}

func (v *VfsImpl) RegisterProxy(entry *ProxyEntry) {
	v.proxyMutex.Lock()
	defer v.proxyMutex.Unlock()

	v.proxyTable = append(v.proxyTable, entry)
}

// Proxy2Service 通用服务代理处理函数
func (v *VfsImpl) Proxy2Service(c *gin.Context, node *models.VfsNode) bool {
	exts := strings.Split(node.Name, ".")
	var serviceName = exts[1]
	// log.Println("Proxy2Service: ", serviceName)
	// 查找对应的代理
	proxy := v.FindProxyByServiceName(serviceName)
	if proxy == nil {
		c.JSON(http.StatusNotImplemented, api.Error{
			Errtype: "error",
			Message: "Service proxy not found for: " + serviceName,
		})
		return false
	}

	// 根据HTTP方法调用相应的代理方法
	switch c.Request.Method {
	case http.MethodGet:
		result, err := proxy.Get(c, serviceName, node)
		if err != nil {
			c.JSON(http.StatusInternalServerError, api.Error{
				Errtype: "error",
				Message: "Failed to get service data: " + err.Error(),
			})
			return false
		}

		c.JSON(http.StatusOK, result)
		return true
	case http.MethodPost:
		// 读取请求体数据
		data, err := c.GetRawData()
		if err != nil {
			c.JSON(http.StatusBadRequest, api.Error{
				Errtype: "error",
				Message: "Failed to read request data: " + err.Error(),
			})
			return false
		}

		resourceID, err := proxy.Create(c, serviceName, node, data)
		if err != nil {
			c.JSON(http.StatusInternalServerError, api.Error{
				Errtype: "error",
				Message: "Failed to create service resource: " + err.Error(),
			})
			return false
		}

		c.JSON(http.StatusCreated, gin.H{"resource_id": resourceID})
		return true
	case http.MethodPut, http.MethodPatch:
		// 读取请求体数据
		data, err := c.GetRawData()
		if err != nil {
			c.JSON(http.StatusBadRequest, api.Error{
				Errtype: "error",
				Message: "Failed to read request data: " + err.Error(),
			})
			return false
		}

		err = proxy.Update(c, serviceName, node, data)
		if err != nil {
			c.JSON(http.StatusInternalServerError, api.Error{
				Errtype: "error",
				Message: "Failed to update service resource: " + err.Error(),
			})
			return false
		}

		c.JSON(http.StatusOK, gin.H{"message": "Updated successfully"})
		return true
	case http.MethodDelete:
		err := proxy.Delete(c, serviceName, node)
		if err != nil {
			c.JSON(http.StatusInternalServerError, api.Error{
				Errtype: "error",
				Message: "Failed to delete service resource: " + err.Error(),
			})
			return false
		}

		c.JSON(http.StatusNoContent, nil)
		return true
	default:
		c.JSON(http.StatusMethodNotAllowed, api.Error{
			Errtype: "error",
			Message: "Method not allowed",
		})
		return false
	}
}