package main

import (
	"context"
	"fmt"
	"net/http"
	"os"
	"os/signal"
	"syscall"
	"time"

	"bsm/full/all/internal/config"
	"bsm/full/all/internal/impl"
	allserver "bsm/full/all/internal/server"
	ads "bsm/full/module/base/ads/service"
	cloud "bsm/full/module/base/cloud/service"
	cms "bsm/full/module/base/cms/service"
	feedback "bsm/full/module/base/feedback/service"
	fts "bsm/full/module/base/fts/service"
	initial "bsm/full/module/base/initial/service"
	logs "bsm/full/module/base/logs/service"
	mgt "bsm/full/module/base/mgt/service"
	passport "bsm/full/module/base/passport/service"
	sender "bsm/full/module/base/sender/service"
	address "bsm/full/module/ec/address/service"
	mall "bsm/full/module/ec/mall/service"
	market "bsm/full/module/ec/market/service"
	order "bsm/full/module/ec/order/service"
	wallet "bsm/full/module/finance/wallet/service"
	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/cookie"
	"google.golang.org/grpc"
)

func main() {
	config.New()
	impl.NewImpl()
	srv := allserver.New()
	srv.HTTP.Use(sessions.Sessions("mysession", cookie.NewStore([]byte(config.Spec.SecretKey+"-session"))))

	exposeGRPC := func(name string, expose func(*grpc.Server) error) {
		if !config.Enabled(name) {
			return
		}
		if err := expose(srv.GRPC); err != nil {
			panic(fmt.Errorf("expose %s: %w", name, err))
		}
	}

	exposeGRPC("ads", func(g *grpc.Server) error {
		return ads.Expose(ads.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("cloud", func(g *grpc.Server) error {
		return cloud.Expose(cloud.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("cms", func(g *grpc.Server) error {
		return cms.Expose(cms.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("feedback", func(g *grpc.Server) error {
		return feedback.Expose(feedback.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("initial", func(g *grpc.Server) error {
		return initial.Expose(initial.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("passport", func(g *grpc.Server) error {
		return passport.Expose(passport.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("sender", func(g *grpc.Server) error {
		return sender.Expose(sender.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("address", func(g *grpc.Server) error {
		return address.Expose(address.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("mall", func(g *grpc.Server) error {
		return mall.Expose(mall.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("market", func(g *grpc.Server) error {
		return market.Expose(market.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("order", func(g *grpc.Server) error {
		return order.Expose(order.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})
	exposeGRPC("wallet", func(g *grpc.Server) error {
		return wallet.Expose(wallet.ExposeOptions{GRPC: g, Gateway: srv.Gateway})
	})

	exposeHTTP := func(name string, expose func() error) {
		if !config.Enabled(name) {
			return
		}
		if err := expose(); err != nil {
			panic(fmt.Errorf("expose %s: %w", name, err))
		}
	}
	exposeHTTP("fts", func() error { return fts.Expose(srv.HTTP) })
	exposeHTTP("logs", func() error { return logs.Expose(srv.HTTP) })
	exposeHTTP("mgt", func() error { return mgt.Expose(srv.HTTP) })

	stop := make(chan os.Signal, 1)
	signal.Notify(stop, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		<-stop
		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
		defer cancel()
		_ = srv.Stop(ctx)
	}()
	if err := srv.Start(config.Spec.Addr); err != nil && err != http.ErrServerClosed {
		panic(err)
	}
}