package http

import (
	"path/filepath"

	"backend/modules/medias"
	"backend/modules/middlewares"
	"backend/modules/users"
	wechatModule "backend/modules/wechat"
	"backend/providers/app"
	"backend/providers/hashids"
	"backend/providers/http"
	"backend/providers/jwt"
	"backend/providers/postgres"
	"backend/providers/storage"
	"backend/providers/wechat"

	"git.ipao.vip/rogeecn/atom"
	"git.ipao.vip/rogeecn/atom/container"
	"git.ipao.vip/rogeecn/atom/contracts"
	"github.com/gofiber/fiber/v3"
	"github.com/gofiber/fiber/v3/middleware/favicon"
	"github.com/gofiber/fiber/v3/middleware/static"
	log "github.com/sirupsen/logrus"
	"github.com/spf13/cobra"
	"go.uber.org/dig"
)

func defaultProviders(providers ...container.ProviderContainer) container.Providers {
	return append(container.Providers{
		app.DefaultProvider(),
		http.DefaultProvider(),
		postgres.DefaultProvider(),
		jwt.DefaultProvider(),
		hashids.DefaultProvider(),
	}, providers...)
}

func Command() atom.Option {
	return atom.Command(
		atom.Name("serve"),
		atom.Short("run http server"),
		atom.RunE(Serve),
		atom.Providers(defaultProviders(
			storage.DefaultProvider(),
			wechat.DefaultProvider(),
		).With(
			middlewares.Provide,
			users.Provide,
			medias.Provide,
			wechatModule.Provide,
		)),
	)
}

type Http struct {
	dig.In

	App         *app.Config
	Storage     *storage.Config
	Wechat      *wechatModule.Controller
	Service     *http.Service
	Initials    []contracts.Initial   `group:"initials"`
	Routes      []contracts.HttpRoute `group:"routes"`
	Middlewares *middlewares.Middlewares
}

func Serve(cmd *cobra.Command, args []string) error {
	return container.Container.Invoke(func(http Http) error {
		if http.App.Mode == app.AppModeDevelopment {
			log.SetLevel(log.DebugLevel)
		}
		engine := http.Service.Engine
		mid := http.Middlewares

		engine.Use(mid.DebugMode)
		engine.Use(mid.ProcessResponse)
		engine.Use(mid.WeChatVerify)

		engine.Use([]string{"/t/:tenant", "/t/:tenant/*"}, mid.WeChatAuth, http.Wechat.Render)
		engine.Get("MP_verify_dEF9kn8rJlBsuLKk.txt", func(c fiber.Ctx) error {
			return c.SendString("dEF9kn8rJlBsuLKk")
		})
		engine.Get("/posters/:tenant/:hash.jpg", func(c fiber.Ctx) error {
			tenant := c.Params("tenant")
			hash := c.Params("hash")

			return c.SendFile(filepath.Join(
				http.Storage.Path,
				tenant,
				hash+".jpg",
			))
		})

		http.Service.Engine.Use(favicon.New(favicon.Config{
			Data: []byte{},
		}))

		http.Service.Engine.Use("/assets", static.New(filepath.Join(http.Storage.Asset, "assets"), static.Config{
			Browse: http.App.IsDevMode(),
		}))

		group := http.Service.Engine.Group("/v1")
		group.Use(mid.ParseJWT)

		for _, route := range http.Routes {
			route.Register(group)
		}

		return http.Service.Serve()
	})
}