package main

import (
	"context"
	"fmt"
	l "gateway-ui/log"
	"gateway-ui/service"
	"gateway-ui/ui"

	"log"
	"net/http"
	"os"
	"os/signal"
	"time"

	assetfs "github.com/elazarl/go-bindata-assetfs"
	"github.com/gin-gonic/gin"
)

const (
	defLogLevel = "debug"
)

func InitRouter(logger l.Logger) *gin.Engine {
	r := gin.Default()
	var (
		css = assetfs.AssetFS{
			Asset:     ui.Asset,
			AssetDir:  ui.AssetDir,
			AssetInfo: nil,
			Prefix:    "ui/dist/css",
			Fallback:  "index.html",
		}
		img = assetfs.AssetFS{
			Asset:     ui.Asset,
			AssetDir:  ui.AssetDir,
			AssetInfo: nil,
			Prefix:    "ui/dist/img",
			Fallback:  "index.html",
		}
		js = assetfs.AssetFS{
			Asset:     ui.Asset,
			AssetDir:  ui.AssetDir,
			AssetInfo: nil,
			Prefix:    "ui/dist/js",
			Fallback:  "index.html",
		}

		fs = assetfs.AssetFS{
			Asset:     ui.Asset,
			AssetDir:  ui.AssetDir,
			AssetInfo: nil,
			Prefix:    "ui/dist",
			Fallback:  "index.html",
		}
	)
	// 加载静态文件
	r.StaticFS("/favicon.ico", &fs)
	r.StaticFS("/config.ts", &fs)
	r.StaticFS("/css", &css)
	r.StaticFS("/img", &img)
	r.StaticFS("/js", &js)

	r.GET("/", func(ctx *gin.Context) {
		ctx.Writer.WriteHeader(http.StatusOK)
		indexHTML, _ := ui.Asset("ui/dist/index.html")
		ctx.Writer.Write(indexHTML)
		ctx.Writer.Header().Add("Accept", "text/html")
		ctx.Writer.Flush()
	})

	r.Use(func(context *gin.Context) {
		method := context.Request.Method
		context.Header("Access-Control-Allow-Origin", "*")
		context.Header("Access-Control-Allow-Headers", "Content-Type,AccessToken,X-CSRF-Token, Authorization, Token")
		context.Header("Access-Control-Allow-Methods", "POST, GET, PUT, OPTIONS")
		context.Header("Access-Control-Expose-Headers", "Content-Length, Access-Control-Allow-Origin, Access-Control-Allow-Headers, Content-Type")
		context.Header("Access-Control-Allow-Credentials", "true")
		if method == "OPTIONS" {
			context.AbortWithStatus(http.StatusNoContent)
		}
		context.Next()
	})
	api := r.Group("/api")

	h := service.InitHandler(logger)

	api.GET("/ping", h.Ping)

	api.GET("/conf", h.GetConf)

	api.PUT("/conf", h.SetConf)

	api.PUT("/upgrade", h.Upgrade)

	api.POST("/token", h.GetToken)

	return r
}

func main() {
	// 初始化日志
	logger, err := l.New(os.Stdout, defLogLevel)
	if err != nil {
		log.Fatalf(fmt.Sprintf("failed to create logger: %s", err))
	}

	r := InitRouter(logger)

	srv := &http.Server{
		Addr:    "0.0.0.0:9000",
		Handler: r,
	}

	// Listen and Server in 0.0.0.0:8080
	go func() {
		if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
			logger.Error(fmt.Sprintf("listen: %s", err))
		}
	}()

	// 等待interrupt信号，10秒的超时后关闭服务
	quit := make(chan os.Signal, 1)
	signal.Notify(quit, os.Interrupt)
	<-quit
	logger.Info("shutdown server...")

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	if err := srv.Shutdown(ctx); err != nil {
		logger.Error(fmt.Sprintf("server shutdown: %s", err))
	}

	logger.Info("server exiting!")
}