package main

import (
	"context"
	"crypto/ecdsa"
	"fmt"
	"os"

	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/client"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container"
	sdkCid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/netmap"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/pool"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/user"
	"github.com/nspcc-dev/neo-go/pkg/crypto/keys"
	"github.com/nspcc-dev/neo-go/pkg/wallet"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
)

func main() {
	cnrCreateListPool()
	fmt.Println("\nDone")
}

func cnrCreateListPool() {
	key := getPrivKey("wallet.json")
	policy := parsePlacementPolicy("REP 1")
	var cnr container.Container
	cnr.Init()

	var idOwner user.ID
	user.IDFromKey(&idOwner, key.PublicKey)
	cnr.SetOwner(idOwner)
	cnr.SetPlacementPolicy(*policy)
	clientParams := client.PrmContainerPut{
		Container: &cnr,
		Session:   nil,
	}

	var poolPrm pool.InitParameters
	poolPrm.SetKey(key)
	poolPrm.AddNode(pool.NewNodeParam(1, "127.0.0.1:8082", 0.8))
	log, err := newConsoleLogger()
	checkErr(err, "failed to build logger")
	poolPrm.SetLogger(log)
	poolPrm.SetSessionExpirationDuration(100)
	p, err := pool.NewPool(poolPrm)
	checkErr(err, "failed to create pool")

	err = p.Dial(context.Background())
	checkErr(err, "failed to dial")

	putPrm := pool.PrmContainerPut{
		ClientParams: clientParams,
	}
	cid, err := p.PutContainer(context.Background(), putPrm)
	checkErr(err, "failed to create container")
	fmt.Println("Put container cid: ", cid)

	listPrm := pool.PrmListStream{
		OwnerID: idOwner,
		Session: nil,
	}
	res, err := p.ListContainersStream(context.Background(), listPrm)
	checkErr(err, "failed to list containers")

	// buf := make([]sdkCid.ID, 10)
	// _, err = res.Read(buf)
	// if !errors.Is(err, io.EOF) {
	// 	checkErr(err, "failed to read ResListStream")
	// }

	fmt.Println("Read container list:")
	err = res.Iterate(func(i sdkCid.ID) bool {
		fmt.Println("cid: ", i)
		return false
	})
	checkErr(err, "failed to read container ids")

	nodesStat := p.Statistic().Nodes()
	for _, n := range nodesStat {
		fmt.Println("Put avg: ", n.AveragePutContainer())
		fmt.Println("ListStream avg: ", n.AverageListContainerStream())
	}
	p.Close()
}

func checkErr(err error, msg string) {
	if err != nil {
		fmt.Println(msg)
		os.Exit(1)
	}
}

func getPrivKey(keyDesc string) *ecdsa.PrivateKey {
	data, err := os.ReadFile(keyDesc)
	if err != nil {
		return nil
	}

	priv, err := keys.NewPrivateKeyFromBytes(data)
	if err != nil {
		w, err := wallet.NewWalletFromFile(keyDesc)
		if err == nil {
			return FromWallet(w)
		}
		return nil
	}
	return &priv.PrivateKey
}

func FromWallet(w *wallet.Wallet) *ecdsa.PrivateKey {
	addr := w.GetChangeAddress()
	acc := w.GetAccount(addr)
	if acc == nil {
		fmt.Printf("Can't find wallet account for %s\n", &addr)
		return nil
	}
	pass := ""
	if err := acc.Decrypt(pass, keys.NEP2ScryptParams()); err != nil {
		fmt.Printf("Can't decrypt account: %v\n", err)
		return nil
	}

	return &acc.PrivateKey().PrivateKey
}

func parsePlacementPolicy(policyString string) *netmap.PlacementPolicy {
	var result netmap.PlacementPolicy
	err := result.DecodeString(policyString)
	if err == nil {
		// fmt.Println("Parsed QL encoded policy")
		return &result
	}

	if err := result.UnmarshalJSON([]byte(policyString)); err == nil {
		// fmt.Println("Parsed JSON encoded policy")
		return &result
	}

	return nil
}

func newConsoleLogger() (*zap.Logger, error) {
	lvl := zap.NewAtomicLevelAt(zapcore.InfoLevel)

	c := zap.NewProductionConfig()
	c.Level = lvl
	c.Encoding = "console"

	c.EncoderConfig.TimeKey = ""

	return c.Build(
		zap.AddStacktrace(zap.NewAtomicLevelAt(zap.FatalLevel)),
		zap.AddCallerSkip(1),
	)
}