package vfs_service

import (
	"fmt"
	"net/http"
	"strings"
	"sync"

	"git.zzyxyz.com/zzy/zzyxyz_go_api/internal/vfs/models"
)

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

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

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

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

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

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

type ProxyService struct {
	Proxies    []*ProxyEntry
	proxyMutex sync.RWMutex
}

func NewProxyService() *ProxyService {
	return &ProxyService{
		Proxies:    make([]*ProxyEntry, 0),
		proxyMutex: sync.RWMutex{},
	}
}

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

	if serviceName == "" {
		return nil
	}

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

	return nil
}

func (s *ProxyService) RegisterProxy(entry *ProxyEntry) {
	s.proxyMutex.Lock()
	defer s.proxyMutex.Unlock()

	s.Proxies = append(s.Proxies, entry)
}

func (s *ProxyService) StrictProxy2Service(method string, data []byte, node *models.VfsNode) ([]byte, error) {
	if node.Type != models.VfsNodeTypeService {
		return nil, fmt.Errorf("node is not a service")
	}
	exts := strings.Split(node.Name, ".")
	var serviceName = exts[1]
	// log.Println("Proxy2Service: ", serviceName)
	// 查找对应的代理
	proxy := s.findProxyByServiceName(serviceName)
	if proxy == nil {
		return nil, fmt.Errorf("service proxy not found for: %s", serviceName)
	}

	// 根据HTTP方法调用相应的代理方法
	switch method {
	case http.MethodGet:
		result, err := proxy.Get(serviceName, node)
		if err != nil {
			return nil, fmt.Errorf("failed to get service data: %v", err)
		}
		return result, nil
	case http.MethodPost:
		// 读取请求体数据
		result, err := proxy.Create(serviceName, node, data)
		if err != nil {
			return nil, fmt.Errorf("failed to create service resource: %v", err)
		}
		return result, nil
	case http.MethodPut, http.MethodPatch:
		// 读取请求体数据
		err := proxy.Update(serviceName, node, data)
		if err != nil {
			return nil, fmt.Errorf("failed to update service resource: %v", err)
		}
		return nil, nil
	case http.MethodDelete:
		err := proxy.Delete(serviceName, node)
		if err != nil {
			return nil, fmt.Errorf("failed to delete service resource: %v", err)
		}
		return nil, nil
	default:
		return nil, fmt.Errorf("method not allowed")
	}
}