package app

import (
	"context"
	"path/filepath"

	appchainmgr "github.com/meshplus/bitxhub-core/appchain-mgr"
	"github.com/meshplus/bitxhub-kit/crypto"
	"github.com/meshplus/bitxhub-kit/storage"
	"github.com/meshplus/bitxhub-kit/storage/leveldb"
	"github.com/sirupsen/logrus"

	"gitlab.33.cn/link33/sidecar/api"
	_ "gitlab.33.cn/link33/sidecar/imports"
	"gitlab.33.cn/link33/sidecar/internal"
	"gitlab.33.cn/link33/sidecar/internal/appchain"
	"gitlab.33.cn/link33/sidecar/internal/loggers"
	"gitlab.33.cn/link33/sidecar/internal/manger"
	"gitlab.33.cn/link33/sidecar/internal/peermgr"
	"gitlab.33.cn/link33/sidecar/internal/repo"
	"gitlab.33.cn/link33/sidecar/internal/router"
	"gitlab.33.cn/link33/sidecar/internal/rulemgr"
	"gitlab.33.cn/link33/sidecar/internal/txcrypto"
	"gitlab.33.cn/link33/sidecar/pkg/plugins"
	"gitlab.33.cn/link33/sidecar/tool"
)

// App represents the necessary data for starting the sidecar app
type App struct {
	privateKey crypto.PrivateKey
	storage    storage.Storage
	ctx        context.Context
	cancel     context.CancelFunc
	config     *repo.Config
	logger     logrus.FieldLogger

	manger    internal.Launcher
	apiServer *api.Server
}

// NewSidecar instantiates sidecar instance.
func NewSidecar(repoRoot string, config *repo.Config) (internal.Launcher, error) {
	store, err := leveldb.New(filepath.Join(config.RepoRoot, "store"))
	tool.Asset(err)
	logger := loggers.Logger(loggers.App)
	//TODO add bls sign
	privateKey, err := repo.LoadPrivateKey(repoRoot)
	tool.Asset(err)
	addr, err := privateKey.PublicKey().Address()
	tool.Asset(err)
	nodePrivKey, err := repo.LoadNodePrivateKey(repoRoot)
	tool.Asset(err)
	var (
	// ck          checker.Checker
	// cryptor     txcrypto.Cryptor
	// apiServer   *apiServer.Server
	)
	r := router.NewRouter(privateKey, loggers.Logger(loggers.Router))
	pm, err := peermgr.New(config, r, nodePrivKey, privateKey, 1, loggers.Logger(loggers.PeerMgr))
	tool.Asset(err)
	clients := plugins.CreateClients(config.Appchains, nil)
	persister := manger.NewPersister(addr.String(), store, loggers.Logger(loggers.Manger))
	appchainMgr := appchainmgr.New(persister)
	// TODO hub client
	// privateKey DH
	cryptor := txcrypto.NewCryptor(nil, appchainMgr, privateKey)
	clientPort := appchain.NewPorts(clients, cryptor, logger)
	r.Adds(clientPort)
	mg, err := manger.NewManager(addr.String(), pm, appchainMgr, loggers.Logger(loggers.Manger))
	tool.Asset(err)

	rule, err := rulemgr.New(store, loggers.Logger(loggers.Rule))
	tool.Asset(err)
	apiServer := api.NewServer(config, pm, rule, loggers.Logger(loggers.ApiServer))
	ctx, cancel := context.WithCancel(context.Background())
	return &App{
		storage:   store,
		logger:    logger,
		ctx:       ctx,
		cancel:    cancel,
		config:    config,
		manger:    mg,
		apiServer: apiServer,
	}, nil
}

// Start starts three main components of sidecar app
func (s *App) Start() error {
	if err := s.apiServer.Start(); err != nil {
		return err
	}

	return s.manger.Start()
}

// Stop stops three main components of sidecar app
func (s *App) Stop() error {
	if err := s.apiServer.Stop(); err != nil {
		return err
	}
	return s.manger.Stop()
}