package main

import (
	"encoding/hex"
	"fmt"
	"os"
	"os/signal"
	"path"
	"strings"

	ethKeystore "github.com/ethereum/go-ethereum/accounts/keystore"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/hermeznetwork/hermez-node/common"
	"github.com/hermeznetwork/hermez-node/config"
	dbUtils "github.com/hermeznetwork/hermez-node/db"
	"github.com/hermeznetwork/hermez-node/db/historydb"
	"github.com/hermeznetwork/hermez-node/db/kvdb"
	"github.com/hermeznetwork/hermez-node/db/l2db"
	"github.com/hermeznetwork/hermez-node/log"
	"github.com/hermeznetwork/hermez-node/node"
	"github.com/hermeznetwork/tracerr"
	"github.com/iden3/go-iden3-crypto/babyjub"
	"github.com/jmoiron/sqlx"
	"github.com/urfave/cli/v2"
)

const (
	flagCfg   = "cfg"
	flagMode  = "mode"
	flagSK    = "privatekey"
	flagYes   = "yes"
	flagBlock = "block"
	modeSync  = "sync"
	modeCoord = "coord"
)

var (
	// version represents the program based on the git tag
	version = "v0.1.0"
	// commit represents the program based on the git commit
	commit = "dev"
	// date represents the date of application was built
	date = ""
)

func cmdVersion(c *cli.Context) error {
	fmt.Printf("Version = \"%v\"\n", version)
	fmt.Printf("Build = \"%v\"\n", commit)
	fmt.Printf("Date = \"%v\"\n", date)
	return nil
}

func cmdGenBJJ(c *cli.Context) error {
	sk := babyjub.NewRandPrivKey()
	skBuf := [32]byte(sk)
	pk := sk.Public()
	fmt.Printf("BJJ = \"0x%s\"\n", pk.String())
	fmt.Printf("BJJPrivateKey = \"0x%s\"\n", hex.EncodeToString(skBuf[:]))
	return nil
}

func cmdImportKey(c *cli.Context) error {
	_cfg, err := parseCli(c)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("error parsing flags and config: %w", err))
	}
	if _cfg.mode != node.ModeCoordinator {
		return tracerr.Wrap(fmt.Errorf("importkey must use mode coordinator"))
	}
	cfg := _cfg.node

	scryptN := ethKeystore.StandardScryptN
	scryptP := ethKeystore.StandardScryptP
	if cfg.Coordinator.Debug.LightScrypt {
		scryptN = ethKeystore.LightScryptN
		scryptP = ethKeystore.LightScryptP
	}
	keyStore := ethKeystore.NewKeyStore(cfg.Coordinator.EthClient.Keystore.Path,
		scryptN, scryptP)
	hexKey := c.String(flagSK)
	hexKey = strings.TrimPrefix(hexKey, "0x")
	sk, err := crypto.HexToECDSA(hexKey)
	if err != nil {
		return tracerr.Wrap(err)
	}
	acc, err := keyStore.ImportECDSA(sk, cfg.Coordinator.EthClient.Keystore.Password)
	if err != nil {
		return tracerr.Wrap(err)
	}
	log.Infow("Imported private key", "addr", acc.Address.Hex())
	return nil
}

func resetStateDBs(cfg *Config, batchNum common.BatchNum) error {
	log.Infof("Reset Synchronizer StateDB to batchNum %v...", batchNum)

	// Manually make a checkpoint from batchNum to current to force current
	// to be a valid checkpoint.  This is useful because in case of a
	// crash, current can be corrupted and the first thing that
	// `kvdb.NewKVDB` does is read the current checkpoint, which wouldn't
	// succeed in case of corruption.
	dbPath := cfg.node.StateDB.Path
	source := path.Join(dbPath, fmt.Sprintf("%s%d", kvdb.PathBatchNum, batchNum))
	current := path.Join(dbPath, kvdb.PathCurrent)
	last := path.Join(dbPath, kvdb.PathLast)
	if err := os.RemoveAll(last); err != nil {
		return tracerr.Wrap(fmt.Errorf("os.RemoveAll: %w", err))
	}
	if batchNum == 0 {
		if err := os.RemoveAll(current); err != nil {
			return tracerr.Wrap(fmt.Errorf("os.RemoveAll: %w", err))
		}
	} else {
		if err := kvdb.PebbleMakeCheckpoint(source, current); err != nil {
			return tracerr.Wrap(fmt.Errorf("kvdb.PebbleMakeCheckpoint: %w", err))
		}
	}
	db, err := kvdb.NewKVDB(kvdb.Config{
		Path:        dbPath,
		NoGapsCheck: true,
		NoLast:      true,
	})
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("kvdb.NewKVDB: %w", err))
	}
	if err := db.Reset(batchNum); err != nil {
		return tracerr.Wrap(fmt.Errorf("db.Reset: %w", err))
	}

	if cfg.mode == node.ModeCoordinator {
		log.Infof("Wipe Coordinator StateDBs...")

		// We wipe the Coordinator StateDBs entirely (by deleting
		// current and resetting to batchNum 0) because the Coordinator
		// StateDBs are always reset from Synchronizer when the
		// coordinator pipeline starts.
		dbPath := cfg.node.Coordinator.TxSelector.Path
		current := path.Join(dbPath, kvdb.PathCurrent)
		if err := os.RemoveAll(current); err != nil {
			return tracerr.Wrap(fmt.Errorf("os.RemoveAll: %w", err))
		}
		db, err := kvdb.NewKVDB(kvdb.Config{
			Path:        dbPath,
			NoGapsCheck: true,
			NoLast:      true,
		})
		if err != nil {
			return tracerr.Wrap(fmt.Errorf("kvdb.NewKVDB: %w", err))
		}
		if err := db.Reset(0); err != nil {
			return tracerr.Wrap(fmt.Errorf("db.Reset: %w", err))
		}

		dbPath = cfg.node.Coordinator.BatchBuilder.Path
		current = path.Join(dbPath, kvdb.PathCurrent)
		if err := os.RemoveAll(current); err != nil {
			return tracerr.Wrap(fmt.Errorf("os.RemoveAll: %w", err))
		}
		db, err = kvdb.NewKVDB(kvdb.Config{
			Path:        dbPath,
			NoGapsCheck: true,
			NoLast:      true,
		})
		if err != nil {
			return tracerr.Wrap(fmt.Errorf("statedb.NewKVDB: %w", err))
		}
		if err := db.Reset(0); err != nil {
			return tracerr.Wrap(fmt.Errorf("db.Reset: %w", err))
		}
	}
	return nil
}

func cmdWipeSQL(c *cli.Context) error {
	_cfg, err := parseCli(c)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("error parsing flags and config: %w", err))
	}
	cfg := _cfg.node
	yes := c.Bool(flagYes)
	if !yes {
		fmt.Print("*WARNING* Are you sure you want to delete " +
			"the SQL DB and StateDBs? [y/N]: ")
		var input string
		if _, err := fmt.Scanln(&input); err != nil {
			return tracerr.Wrap(err)
		}
		input = strings.ToLower(input)
		if !(input == "y" || input == "yes") {
			return nil
		}
	}
	db, err := dbUtils.ConnectSQLDB(
		cfg.PostgreSQL.PortWrite,
		cfg.PostgreSQL.HostWrite,
		cfg.PostgreSQL.UserWrite,
		cfg.PostgreSQL.PasswordWrite,
		cfg.PostgreSQL.NameWrite,
	)
	if err != nil {
		return tracerr.Wrap(err)
	}
	log.Info("Wiping SQL DB...")
	if err := dbUtils.MigrationsDown(db.DB); err != nil {
		return tracerr.Wrap(fmt.Errorf("dbUtils.MigrationsDown: %w", err))
	}

	log.Info("Wiping StateDBs...")
	if err := resetStateDBs(_cfg, 0); err != nil {
		return tracerr.Wrap(fmt.Errorf("resetStateDBs: %w", err))
	}
	return nil
}

func waitSigInt() {
	stopCh := make(chan interface{})

	// catch ^C to send the stop signal
	ossig := make(chan os.Signal, 1)
	signal.Notify(ossig, os.Interrupt)
	const forceStopCount = 3
	go func() {
		n := 0
		for sig := range ossig {
			if sig == os.Interrupt {
				log.Info("Received Interrupt Signal")
				stopCh <- nil
				n++
				if n == forceStopCount {
					log.Fatalf("Received %v Interrupt Signals", forceStopCount)
				}
			}
		}
	}()
	<-stopCh
}

func cmdRun(c *cli.Context) error {
	cfg, err := parseCli(c)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("error parsing flags and config: %w", err))
	}
	node, err := node.NewNode(cfg.mode, cfg.node)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("error starting node: %w", err))
	}
	node.Start()
	waitSigInt()
	node.Stop()

	return nil
}

func cmdServeAPI(c *cli.Context) error {
	cfg, err := parseCliAPIServer(c)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("error parsing flags and config: %w", err))
	}
	srv, err := node.NewAPIServer(cfg.mode, cfg.server)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("error starting api server: %w", err))
	}
	srv.Start()
	waitSigInt()
	srv.Stop()

	return nil
}

func cmdDiscard(c *cli.Context) error {
	_cfg, err := parseCli(c)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("error parsing flags and config: %w", err))
	}
	cfg := _cfg.node
	blockNum := c.Int64(flagBlock)
	log.Infof("Discarding all blocks up to block %v...", blockNum)

	dbWrite, err := dbUtils.InitSQLDB(
		cfg.PostgreSQL.PortWrite,
		cfg.PostgreSQL.HostWrite,
		cfg.PostgreSQL.UserWrite,
		cfg.PostgreSQL.PasswordWrite,
		cfg.PostgreSQL.NameWrite,
	)
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
	}
	var dbRead *sqlx.DB
	if cfg.PostgreSQL.HostRead == "" {
		dbRead = dbWrite
	} else if cfg.PostgreSQL.HostRead == cfg.PostgreSQL.HostWrite {
		return tracerr.Wrap(fmt.Errorf(
			"PostgreSQL.HostRead and PostgreSQL.HostWrite must be different",
		))
	} else {
		dbRead, err = dbUtils.InitSQLDB(
			cfg.PostgreSQL.PortRead,
			cfg.PostgreSQL.HostRead,
			cfg.PostgreSQL.UserRead,
			cfg.PostgreSQL.PasswordRead,
			cfg.PostgreSQL.NameRead,
		)
		if err != nil {
			return tracerr.Wrap(fmt.Errorf("dbUtils.InitSQLDB: %w", err))
		}
	}
	historyDB := historydb.NewHistoryDB(dbRead, dbWrite, nil)
	if err := historyDB.Reorg(blockNum); err != nil {
		return tracerr.Wrap(fmt.Errorf("historyDB.Reorg: %w", err))
	}
	batchNum, err := historyDB.GetLastBatchNum()
	if err != nil {
		return tracerr.Wrap(fmt.Errorf("historyDB.GetLastBatchNum: %w", err))
	}
	l2DB := l2db.NewL2DB(
		dbRead, dbWrite,
		cfg.Coordinator.L2DB.SafetyPeriod,
		cfg.Coordinator.L2DB.MaxTxs,
		cfg.Coordinator.L2DB.MinFeeUSD,
		cfg.Coordinator.L2DB.MaxFeeUSD,
		cfg.Coordinator.L2DB.TTL.Duration,
		nil,
	)
	if err := l2DB.Reorg(batchNum); err != nil {
		return tracerr.Wrap(fmt.Errorf("l2DB.Reorg: %w", err))
	}

	log.Info("Resetting StateDBs...")
	if err := resetStateDBs(_cfg, batchNum); err != nil {
		return tracerr.Wrap(fmt.Errorf("resetStateDBs: %w", err))
	}

	return nil
}

// Config is the configuration of the hermez node execution
type Config struct {
	mode node.Mode
	node *config.Node
}

func parseCli(c *cli.Context) (*Config, error) {
	cfg, err := getConfig(c)
	if err != nil {
		if err := cli.ShowAppHelp(c); err != nil {
			panic(err)
		}
		return nil, tracerr.Wrap(err)
	}
	return cfg, nil
}

func getConfig(c *cli.Context) (*Config, error) {
	var cfg Config
	mode := c.String(flagMode)
	nodeCfgPath := c.String(flagCfg)
	var err error
	switch mode {
	case modeSync:
		cfg.mode = node.ModeSynchronizer
		cfg.node, err = config.LoadNode(nodeCfgPath, false)
		if err != nil {
			return nil, tracerr.Wrap(err)
		}
	case modeCoord:
		cfg.mode = node.ModeCoordinator
		cfg.node, err = config.LoadNode(nodeCfgPath, true)
		if err != nil {
			return nil, tracerr.Wrap(err)
		}
	default:
		return nil, tracerr.Wrap(fmt.Errorf("invalid mode \"%v\"", mode))
	}

	return &cfg, nil
}

// ConfigAPIServer is the configuration of the api server execution
type ConfigAPIServer struct {
	mode   node.Mode
	server *config.APIServer
}

func parseCliAPIServer(c *cli.Context) (*ConfigAPIServer, error) {
	cfg, err := getConfigAPIServer(c)
	if err != nil {
		if err := cli.ShowAppHelp(c); err != nil {
			panic(err)
		}
		return nil, tracerr.Wrap(err)
	}
	return cfg, nil
}

func getConfigAPIServer(c *cli.Context) (*ConfigAPIServer, error) {
	var cfg ConfigAPIServer
	mode := c.String(flagMode)
	nodeCfgPath := c.String(flagCfg)
	var err error
	switch mode {
	case modeSync:
		cfg.mode = node.ModeSynchronizer
		cfg.server, err = config.LoadAPIServer(nodeCfgPath, false)
		if err != nil {
			return nil, tracerr.Wrap(err)
		}
	case modeCoord:
		cfg.mode = node.ModeCoordinator
		cfg.server, err = config.LoadAPIServer(nodeCfgPath, true)
		if err != nil {
			return nil, tracerr.Wrap(err)
		}
	default:
		return nil, tracerr.Wrap(fmt.Errorf("invalid mode \"%v\"", mode))
	}

	return &cfg, nil
}

func main() {
	app := cli.NewApp()
	app.Name = "hermez-node"
	app.Version = version
	flags := []cli.Flag{
		&cli.StringFlag{
			Name:     flagMode,
			Usage:    fmt.Sprintf("Set node `MODE` (can be \"%v\" or \"%v\")", modeSync, modeCoord),
			Required: true,
		},
		&cli.StringFlag{
			Name:     flagCfg,
			Usage:    "Node configuration `FILE`",
			Required: true,
		},
	}

	app.Commands = []*cli.Command{
		{
			Name:    "version",
			Aliases: []string{},
			Usage:   "Show the application version and build",
			Action:  cmdVersion,
		},
		{
			Name:    "importkey",
			Aliases: []string{},
			Usage:   "Import ethereum private key",
			Action:  cmdImportKey,
			Flags: append(flags,
				&cli.StringFlag{
					Name:     flagSK,
					Usage:    "ethereum `PRIVATE_KEY` in hex",
					Required: true,
				}),
		},
		{
			Name:    "genbjj",
			Aliases: []string{},
			Usage:   "Generate a new BabyJubJub key",
			Action:  cmdGenBJJ,
		},
		{
			Name:    "wipesql",
			Aliases: []string{},
			Usage: "Wipe the SQL DB (HistoryDB and L2DB) and the StateDBs, " +
				"leaving the DB in a clean state",
			Action: cmdWipeSQL,
			Flags: append(flags,
				&cli.BoolFlag{
					Name:     flagYes,
					Usage:    "automatic yes to the prompt",
					Required: false,
				}),
		},
		{
			Name:    "run",
			Aliases: []string{},
			Usage:   "Run the hermez-node in the indicated mode",
			Action:  cmdRun,
			Flags:   flags,
		},
		{
			Name:    "serveapi",
			Aliases: []string{},
			Usage:   "Serve the API only",
			Action:  cmdServeAPI,
			Flags:   flags,
		},
		{
			Name:    "discard",
			Aliases: []string{},
			Usage:   "Discard blocks up to a specified block number",
			Action:  cmdDiscard,
			Flags: append(flags,
				&cli.Int64Flag{
					Name:     flagBlock,
					Usage:    "last block number to keep",
					Required: false,
				}),
		},
	}

	err := app.Run(os.Args)
	if err != nil {
		fmt.Printf("\nError: %v\n", tracerr.Sprint(err))
		os.Exit(1)
	}
}