package http

import (
	"fmt"

	"github.com/gin-gonic/gin"
	"github.com/infraboard/mcube/logger"
	"github.com/infraboard/mcube/logger/zap"

	"gitee.com/player1111/restful-api-demo.git/apps"
	"gitee.com/player1111/restful-api-demo.git/apps/host"
	"gitee.com/player1111/restful-api-demo.git/apps/server"
)

type HandlerFactory struct{}

func init() {
	/*	var err error
		handlerFactory := NewHandlerFactory()
		hanlderService := NewHandlerService()

		// 将带服务参的handler加入factory
		hostHandler, err := handlerFactory.NewHandler(apps.HostService)
		serverHandler, err := handlerFactory.NewHandler(apps.ServerService)

		if err != nil {
			fmt.Println(err)
		}

		//将handler加入到service列表中管理
		hanlderService.RegistryHandlers(hostHandler)
		hanlderService.RegistryHandlers(serverHandler)*/

	//service.HandlerServiceGlobal = hanlderService

	/*hostService := NewHttpService(hostHandler)
	serverService := NewHttpService(serverHandler)*/

	/*apps.RegistryHttp(hostHandler)
	apps.RegistryHttp(serverHandler)*/
	/*	apps.RegistryHttp(hostService)
		apps.RegistryHttp(serverService)*/
}

func NewHandlerFactory() *HandlerFactory {
	return &HandlerFactory{}
}

/*func (f *HandlerFactory) NewHandler(service apps.AppService) (Handler, error) {
	switch svc := service.(type) {
	case host.HostService:
		return &HostHandler{svc: svc}, nil
	case server.ServerService:
		return &ServerHandler{svc: svc}, nil
	case nil:
		return nil, fmt.Errorf("service type is nil")
	default:
		return nil, fmt.Errorf("no support service type")
	}
}*/

// 通过写一个实体类，来处理http协议，内部接口暴露
// 需要依赖内部接口的实现
type Handler interface {
	Handle()
	Name() string
	GenerateRoute() string
	Registry(r gin.IRouter)
}

type HostHandler struct {
	svc host.HostService
	log logger.Logger
}

func (h *HostHandler) Handle() {
	fmt.Println("HostHandler handle..")
}

func (h *HostHandler) Name() string {
	return "HostService Handler"
}

func (h *HostHandler) GenerateRoute() string {
	return "/host"
}

func (h *HostHandler) Registry(r gin.IRouter) {
	//POST 请求：POST 请求的语义是向指定的资源提交数据，用于创建新的资源。
	r.POST(h.GenerateRoute(), h.handleCreate)
	r.GET("/host/query", h.handleQuery)
	r.GET("/host/:id", h.handleDescribe)
	r.PATCH("/host/update/:id", h.handleUpdate) //这里我们逻辑写的
	r.PUT("/host/update/:id", h.handleUpdate)

	// (h *HostHandler) handleUpdate(c *gin.Context) -> (i *HostServiceImpl) Update(ctx context.Context, req *host.UpdateHostRequest) (*host.Host, error)    ->    i.update ->
}

/*func NewHostHandler(svc apps.AppService) Handler {
	hostSvc, ok := svc.(host.HostService)
	if !ok {
		return nil
	}
	return &HostHandler{svc: hostSvc}
}*/

func NewHostHandler() Handler {
	return &HostHandler{svc: apps.HostService, log: zap.L().Named("HostHandler")}
}

/*func newHostHandler(svc apps.AppService) (Handler, error) {
	if hostSvc, ok := svc.(host.HostService); ok {
		return &HostHandler{
			svc: hostSvc,
		}, nil
	}
	return nil, fmt.Errorf("unexpected service type: %T\n", svc)
}*/

type ServerHandler struct {
	svc server.ServerService
}

func (h *ServerHandler) Handle() {
	fmt.Println("ServerHandler handle..")
}

func (s *ServerHandler) Name() string {
	return "ServerService Handler"
}

func (s *ServerHandler) GenerateRoute() string {
	return "/server"
}

func (s *ServerHandler) Registry(r gin.IRouter) {
	r.POST(s.GenerateRoute(), s.handleCreate)
}

/*func NewServerHandler(svc apps.AppService) Handler {
	serverSvc, ok := svc.(server.ServerService)
	if !ok {
		return nil
	}
	return &ServerHandler{svc: serverSvc}
}*/

func NewServerHandler() Handler {
	return &ServerHandler{svc: apps.ServerService}
}

/*
func newServerHandler(svc apps.AppService) (Handler, error) {
	if ServerSvc, ok := svc.(server.ServerService); ok {
		return &ServerHandler{
			svc: ServerSvc,
		}, nil
	}
	return nil, fmt.Errorf("unexpected service type: %T\n", svc)
}*/

/*// NewHandler 构造函数，接收服务实例作为参数
func NewHostHandler(svc apps.AppService) HostHandler {
	return HostHandler{svc: svc}
}

func NewServerHandler(service server.ServerService) *Handler {
	return nil
}*/

/*// handlerConfigurator 定义了用于配置处理程序的方法
type handlerConfigurator interface {
	Config()
}

// handlerRegistry 定义了用于注册处理程序路由的方法
type handlerRegistry interface {
	Registry(r gin.IRouter)
}

// handlerNameProvider 定义了用于提供处理程序名称的方法
type handlerNameProvider interface {
	Name() string
}*/

/*// http的核心handler依赖service
func NewHandler() *Handler {
	return &Handler{}
}*/

/*func (h *Handler) Config() {
	h.svc = svc
}*/

/*
func (h *Handler) Name() string {
	switch h.svc.(type) {
	case host.HostService:
		return "HostService Handler"
	case server.ServerService:
		return "ServerService Handler"
	// 添加其他服务类型的处理逻辑
	default:
		return "Not Support ServiceType" // 或者根据需要返回其他默认值
	}
}*/

// generateRoute 根据 svc 属性生成路由路径
/*func (h *Handler) generateRoute() string {
	// 根据 svc 属性的类型生成不同的路由路径
	switch h.svc.(type) {
	case host.HostService:
		return "/host"
	case server.ServerService:
		return "/server"
	// 可根据需要添加其他服务类型的路由生成逻辑
	default:
		// 默认情况下返回空字符串或者其他默认路由路径
		return "/default"
	}
}*/