package main

import (
	"flag"
	"os"

	"sandc/app/eonline/internal/conf"
	config2 "sandc/app/eonline/internal/config"
	"sandc/app/eonline/internal/service"
	"sandc/pkg/log/zaplog"

	zaplogger "github.com/go-kratos/kratos/contrib/log/zap/v2"
	"github.com/go-kratos/kratos/v2"
	"github.com/go-kratos/kratos/v2/config"
	"github.com/go-kratos/kratos/v2/config/file"
	"github.com/go-kratos/kratos/v2/encoding/json"
	"github.com/go-kratos/kratos/v2/log"
	"github.com/go-kratos/kratos/v2/middleware/tracing"
	"github.com/go-kratos/kratos/v2/transport/http"
	"go.opentelemetry.io/otel"
	"go.opentelemetry.io/otel/sdk/resource"
	tracesdk "go.opentelemetry.io/otel/sdk/trace"
	semconv "go.opentelemetry.io/otel/semconv/v1.4.0"
	"google.golang.org/protobuf/encoding/protojson"
)

// go build -ldflags "-X main.Version=x.y.z"
var (
	// Name is the name of the compiled software.
	Name = "eonline.rpc"
	// Version is the version of the compiled software.
	Version = "0.1.0"
	// flagconf is the config flag.
	flagconf string

	id, _ = os.Hostname()
)

func init() {
	flag.StringVar(&flagconf, "conf", "configs/config.yaml", "config path, eg: -conf config.yaml")
	json.MarshalOptions = protojson.MarshalOptions{
		EmitUnpopulated: true,
		UseProtoNames:   true,
	}
}

// func newApp(logger log.Logger, conf *conf.Server, hs *http.Server, gs *grpc.Server, rr registry.Registrar) *kratos.App {
func newApp(logger log.Logger, conf *conf.Server, hs *http.Server) *kratos.App {
	return kratos.New(
		kratos.ID(id),
		kratos.Name(Name),
		kratos.Version(Version),
		kratos.Metadata(map[string]string{}),
		kratos.Logger(logger),
		kratos.Server(
			hs,
			// gs,
		),
		// kratos.Registrar(rr),
	)
}

func main() {
	flag.Parse()

	c := config.New(
		config.WithSource(
			file.NewSource(flagconf),
		),
	)
	if err := c.Load(); err != nil {
		panic(err)
	}

	var bc conf.Bootstrap
	if err := c.Scan(&bc); err != nil {
		panic(err)
	}

	zc := zaplog.NewConfig(zaplog.SetLogPrintTag(false))
	if err := zaplog.Init(zc); err != nil {
		panic(err)
	}

	logger := log.With(zaplogger.NewLogger(zaplog.Logger),
		"ts", log.DefaultTimestamp,
		"caller", log.DefaultCaller,
		"service.id", id,
		"service.name", Name,
		"service.version", Version,
		"trace_id", tracing.TraceID(),
		"span_id", tracing.SpanID(),
	)
	// exp, err := jaeger.New(jaeger.WithCollectorEndpoint(jaeger.WithEndpoint(bc.Server.TraceEndpoint)))
	// if err != nil {
	// 	panic(err)
	// }
	tp := tracesdk.NewTracerProvider(
		// tracesdk.WithBatcher(exp),
		tracesdk.WithResource(resource.NewSchemaless(
			semconv.ServiceNameKey.String(Name),
		)),
	)
	otel.SetTracerProvider(tp)

	config2.ConfigInit(&bc.ConfigFiles.Path, &bc.Server.Env, &bc.Server.VerCheck)
	service.InitTimer()
	defer func() {
		service.OnDestroyTimer()
	}()

	app, cleanup, err := initApp(bc.Server, &bc, bc.Data, bc.Queue, logger)
	if err != nil {
		panic(err)
	}
	defer cleanup()

	// start and wait for stop signal
	if err := app.Run(); err != nil {
		panic(err)
	}
}