package main

import (
	"context"
	"flag"
	"fmt"

	pubsub "github.com/libp2p/go-libp2p-pubsub"
	ipfslite "github.com/hsanjuan/ipfs-lite"
	badger "github.com/ipfs/go-ds-badger2"
	logging "github.com/ipfs/go-log/v2"

	"github.com/k4lipso/pentapass/storage"
	"github.com/k4lipso/pentapass/rpc"
	"github.com/k4lipso/pentapass/crypto/age"
)

var (
	topicNameFlag = flag.String("topicName", "pentapass", "name of topic to join")
	dbPath = flag.String("db", "./db", "db file path")
	nameSpace = flag.String("namespace", "crdt", "namespace")
	logger    = logging.Logger("globaldb")
//	netTopic  = "globaldb-example-net"
//	config    = "globaldb-example"
)


func main() {
	flag.Parse()
	ctx := context.Background()
	data := *dbPath

	key, err := age.LoadOrGenerateKeys(*dbPath + "/age.key")

	if err != nil {
		panic(err)
	}

	fmt.Printf("AgeKey: %s\n", key.String())
	fmt.Printf("AgePublicKey: %s\n", key.Recipient().String())

	//cipher, err := age.Encrypt([]byte("Test Message"), []string{key.Recipient().String()})
	//fmt.Printf("Encrypted: %s\n", cipher)
	//decrypted, err := age.Decrypt(cipher, key)
	//fmt.Printf("Decrypted: %s\n", decrypted)

	h, dht, err := storage.SetupLibp2pHost(ctx, *dbPath)

	fmt.Println(h.ID().String())

	if err != nil {
		panic(err)
	}

	ps, err := pubsub.NewGossipSub(ctx, h)
	if err != nil {
		panic(err)
	}

	//_, err = ps.Join(*topicNameFlag)
	//if err != nil {
	//	panic(err)
	//}

	go storage.DiscoverPeers(ctx, h, dht)

	store, err := badger.NewDatastore(data, &badger.DefaultOptions)
	if err != nil {
		logger.Fatal(err)
	}
	defer store.Close()

	ipfs, err := ipfslite.New(ctx, store, nil, h, dht, nil)
	if err != nil {
		logger.Fatal(err)
	}

	storageHandler := storage.StorageHandler{
		Ctx: ctx ,
		Store: store,
		Host: h,
		Ipfs: ipfs,
		PubSub: ps,
		Key: key,
	}

	Cfg, err := storageHandler.NewConfig(*dbPath + "/config.json")

	if err != nil {
		logger.Fatal(err)
	}

	storageHandler.Config = Cfg
	storageHandler.ConfigPath = *dbPath + "/config.json"
	storageHandler.InitNamespaces()

	for _, val := range storageHandler.Namespaces {
		defer val.Close()
	}

	rpc.StorageHandler = &storageHandler
	rpc.Serve(*dbPath)
}