package authzserver

import (
	"context"
	"fmt"
	"gitee.com/GomiTo/iam/internal/authzserver/analytics"

	"gitee.com/GomiTo/iam/internal/authzserver/config"
	"gitee.com/GomiTo/iam/internal/authzserver/load"
	"gitee.com/GomiTo/iam/internal/authzserver/load/cache"
	"gitee.com/GomiTo/iam/internal/authzserver/store/apiserver"
	genericoptions "gitee.com/GomiTo/iam/internal/pkg/options"
	genericapiserver "gitee.com/GomiTo/iam/internal/pkg/server"
	"gitee.com/GomiTo/iam/pkg/errors"
	"gitee.com/GomiTo/iam/pkg/log"
	storage "gitee.com/GomiTo/iam/pkg/storage_redis"
	"github.com/marmotedu/iam/pkg/shutdown"
	"github.com/marmotedu/iam/pkg/shutdown/shutdownmanagers/posixsignal"
)

const RedisKeyPrefix = "analytics-"


// 构建运行内容
type authzServer struct {
	gs               *shutdown.GracefulShutdown // 优雅关闭
	rpcServer        string                     // rpc 服务 addr
	clientCA         string                     // clientCA文件
	redisOptions     *genericoptions.RedisOptions// redis相关结构体
	genericAPIServer *genericapiserver.GenericAPIServer // 给 http和https构建好应用 返回 外部直接使用
	analyticsOptions *analytics.AnalyticsOptions //   写入日志相关参数
	redisCancelFunc  context.CancelFunc
}


// 构建初始化
type preparedAuthzServer struct {
	*authzServer
}


// 根据配置文件构建服务  添加基础中间件 gin配置 pprof 健康检查
func createAuthzServer(cfg *config.Config) (*authzServer, error) {
	gs := shutdown.New()   // 初始化优雅关闭相关服务
	gs.AddShutdownManager(posixsignal.NewPosixSignalManager()) // 添加信号
	genericConfig, err := buildGenericConfig(cfg) // 根据配置进行   执行应用函数 ApplyTo
	if err != nil {
		return nil, err
	}

	// 根据构建好的配置进行 构建 http和https 服务
	genericServer := genericConfig.NewAndInitApiServer()

	server := &authzServer{
		gs:               gs,
		redisOptions:     cfg.Option.RedisOption,
		analyticsOptions: cfg.Option.AnalyticsOptions,
		rpcServer:        cfg.Option.RPCServer,
		clientCA:         cfg.Option.ClientCA,
		genericAPIServer: genericServer,
	}
	return server, nil
}

// 执行应用函数 ApplyTo
func buildGenericConfig(cfg *config.Config) (genericConfig *genericapiserver.ServerConfig, lastErr error) {

	// 得到基本的配置
	genericConfig = genericapiserver.NewServerConfig()
	// 服务运行前构建的内容
	if lastErr = cfg.Option.ServerRunOption.ApplyTo(genericConfig); lastErr != nil {
		return
	}

	if lastErr = cfg.Option.FeatureOptions.ApplyTo(genericConfig); lastErr != nil {
		return
	}

	if lastErr = cfg.Option.HttpsOption.ApplyTo(genericConfig); lastErr != nil {
		return
	}

	if lastErr = cfg.Option.HttpOption.ApplyTo(genericConfig); lastErr != nil {
		return
	}

	return
}

// 运行authzserver
func (s preparedAuthzServer) Run() error {
	stopCh := make(chan struct{})

	// start shutdown managers
	if err := s.gs.Start(); err != nil {
		log.Fatalf("start shutdown manager failed: %s", err.Error())
	}

	//nolint: errcheck
	go s.genericAPIServer.Run()

	// in order to ensure that the reported data is not lost,
	// please ensure the following graceful shutdown sequence
	s.gs.AddShutdownCallback(shutdown.ShutdownFunc(func(string) error {
		s.genericAPIServer.Close()
		/*if s.analyticsOptions.Enable { // 讲日志添加到 db 中
			analytics.GetAnalytics().Stop()
		}*/
		s.redisCancelFunc()
		return nil
	}))

	// blocking here via channel to prevents the process exit.
	<-stopCh

	return nil
}

// 根据  authzServer 构建准备运行 (router listen等)
func (s *authzServer) PrepareRun() preparedAuthzServer {
	// 维护redis连接 ； 通过gprc服务初始化store ； load相关库启动(redis cache)

	_ = s.initialize()  //缓存机制用到了 Redis key-value 存储，所以在 iam-authz-server 初始化阶段，需要先建立 Redis 连接
	//fmt.Println("initialize*******",err)


	installController(s.genericAPIServer.Engine)   //router内容

	s.gs.AddShutdownCallback(shutdown.ShutdownFunc(func(string) error {
		s.genericAPIServer.Close()

		return nil
	}))

	return preparedAuthzServer{s}
}

// 维护redis连接 初始化grpc
func (s *authzServer)initialize()error  {
	// 建立 redis 连接
	ctx, cancel := context.WithCancel(context.Background())

	s.redisCancelFunc = cancel

	//  第一次建立连接 并且 keep redis connected  维护一个 Redis 连接，如果 Redis 连接断掉，会尝试重连
	go storage.ConnectToRedis(ctx, s.buildStorageConfig()) //

	// 连接grpc服务 并根据grpc传来的接口初始化 store
	//cacheIns, err := cache.GetCacheInsOr(apiserver.GetAPIServerFactoryOrDie(s.rpcServer, s.clientCA))
	// todo:这里不进行加密
	// 这里导致出错
	cacheIns, err := cache.GetCacheInsOr(apiserver.GetAPIServerFactoryOrDie(s.rpcServer, ""))
	if err != nil {
		// 出错
		return errors.Wrap(err, "get cache instance failed")
	}

	// 运行 cache库相关内容 服务
	load.NewLoad(ctx, cacheIns).Start()  //创建并启动一个 Load 服务  **

	fmt.Println("initialize 结束 *********")

	//iam-authz-server 实现数据上报功能 + iam-pump 实现数据采集功能
	// start analytics service  -->  服务中的数据上报功能
	//  是否开启 日志采集服务
	/*if s.analyticsOptions.Enable {
		analyticsStore := storage.RedisCluster{KeyPrefix: RedisKeyPrefix}

		//日志写到 chan 中 然后 在批量投递到Redis
		analyticsIns := analytics.NewAnalytics(s.analyticsOptions, &analyticsStore) //初始化上报服务
		analyticsIns.Start() //启动上报服务

		s.gs.AddShutdownCallback(shutdown.ShutdownFunc(func(string) error { //关闭
			analyticsIns.Stop()
			return nil
		}))
	}
	 */

	// 结束执行
	s.gs.AddShutdownCallback(shutdown.ShutdownFunc(func(string) error {
		cancel()  // 结束 redis 结束 cache

		return nil
	}))

	return nil
}


// 配置redis
func (s *authzServer) buildStorageConfig() *storage.Config {
	return &storage.Config{
		Host:                  s.redisOptions.Host,
		Port:                  s.redisOptions.Port,
		Addrs:                 s.redisOptions.Addrs,
		MasterName:            s.redisOptions.MasterName,
		Username:              s.redisOptions.Username,
		Password:              s.redisOptions.Password,
		Database:              s.redisOptions.Database,
		MaxIdle:               s.redisOptions.MaxIdle,
		MaxActive:             s.redisOptions.MaxActive,
		Timeout:               s.redisOptions.Timeout,
		EnableCluster:         s.redisOptions.EnableCluster,
		UseSSL:                s.redisOptions.UseSSL,
		SSLInsecureSkipVerify: s.redisOptions.SSLInsecureSkipVerify,
	}
}