package main

import (
	"context"
	"fmt"
	"math/big"
	"os"
	"os/signal"
	"runtime/debug"
	"strconv"
	"syscall"

	nftmarket "contract/wrappers/market"
	nicenamesnft "contract/wrappers/nep11"
	awesomeneotoken "contract/wrappers/nep17"

	"github.com/nspcc-dev/neo-go/pkg/encoding/address"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/actor"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/gas"
	"github.com/nspcc-dev/neo-go/pkg/rpcclient/nep17"
	"github.com/nspcc-dev/neo-go/pkg/util"
	"github.com/nspcc-dev/neo-go/pkg/vm/stackitem"
	"github.com/nspcc-dev/neo-go/pkg/wallet"
)

func main() {
	ctx, _ := signal.NotifyContext(context.Background(), syscall.SIGINT, syscall.SIGTERM)

	rpcCli, err := rpcclient.New(ctx, "http://localhost:30333", rpcclient.Options{})
	die(err)

	w, err := wallet.NewWalletFromFile("/home/denis/github/tcl/neofs-aio/wallets/wallet1.json")
	die(err)
	acc := w.GetAccount(w.GetChangeAddress())
	err = acc.Decrypt("", w.Scrypt)
	die(err)

	act, err := actor.NewSimple(rpcCli, acc)
	die(err)

	hashNFT, err := util.Uint160DecodeStringLE("d9ab2450c7cc775f747cde591a65c4735c97831c")
	die(err)
	contractNFT := nicenamesnft.New(act, hashNFT)
	_ = contractNFT

	hashMarket, err := util.Uint160DecodeStringLE("c6a0eb7e12c4a6e1abe293ade33cd62436c46b24")
	die(err)
	contractMarket := nftmarket.New(act, hashMarket)
	_ = contractMarket

	hashToken, err := util.Uint160DecodeStringLE("7724e3048f013163e97015f00850da015154af18")
	die(err)
	contractToken := awesomeneotoken.New(act, hashToken)

	contractGAS := gas.New(act)

	printBalances(contractGAS, contractToken, acc.ScriptHash())
	printMarketNFT(contractMarket)
	buyNFT(act, contractMarket, contractToken, hashMarket, "my-itmo-nft")
	printMarketNFT(contractMarket)
	printNFTs(contractNFT, acc.ScriptHash())
	printBalances(contractGAS, contractToken, acc.ScriptHash())

	//printNFTs(contractNFT, acc.ScriptHash())
	//createNFT(act, contractGAS, hashNFT, "my-itmo-nft")
	//printNFTs(contractNFT, acc.ScriptHash())
	//transferMyTKN(act, contractMarket, acc.ScriptHash())
	//printMarketNFT(contractMarket)
	//sellNFT(act, contractNFT, hashMarket, "for-market")
	//byNFT(act, contractMarket, contractToken, hashMarket, "for-market")
	//printMarketNFT(contractMarket)
	//printNFTs(contractNFT, acc.ScriptHash())

}

func createNFT(act *actor.Actor, contractGAS *nep17.Token, hashNFT util.Uint160, name string) {
	_, err := act.WaitSuccess(contractGAS.Transfer(act.Sender(), hashNFT, big.NewInt(10_0000_0000), name))
	die(err)
}

func printBalances(contractGAS *nep17.Token, contractToken *awesomeneotoken.Contract, owner util.Uint160) {
	fmt.Println("Balances:")

	gasBalance, err := contractGAS.BalanceOf(owner)
	die(err)
	fmt.Println("GAS balance: ", gasBalance.Uint64())

	mytknBalance, err := contractToken.BalanceOf(owner)
	die(err)
	fmt.Println("MYTKN balance: ", mytknBalance.Uint64())
	fmt.Println()
}

func sellNFT(act *actor.Actor, c *nicenamesnft.Contract, to util.Uint160, name string) {
	for _, nft := range listNFTs(c, act.Sender()) {
		if nft.Name == name {
			_, err := act.WaitSuccess(c.Transfer(to, nft.ID, nil))
			die(err)
			return
		}
	}

	fmt.Println("not found nft: ", name)
	fmt.Println()
}

func transferMyTKN(act *actor.Actor, c *nftmarket.Contract, to util.Uint160) {
	_, err := act.WaitSuccess(c.TransferTokens(to, big.NewInt(10_0000_0000)))
	die(err)
}

func buyNFT(act *actor.Actor, c *nftmarket.Contract, ct *awesomeneotoken.Contract, marketHash util.Uint160, name string) {
	for _, nft := range listMarketNFT(c) {
		if nft.Name == name {
			_, err := act.WaitSuccess(ct.Transfer(act.Sender(), marketHash, big.NewInt(10_0000_0000), nft.ID))
			die(err)
			return
		}
	}

	fmt.Println("not found market nft: ", name)
	fmt.Println()
}

func printNFTs(c *nicenamesnft.Contract, owner util.Uint160) {
	res := listNFTs(c, owner)
	fmt.Println("owner nfts:")
	fmt.Println(res)
	fmt.Println()
}

func listNFTs(c *nicenamesnft.Contract, owner util.Uint160) []NFTItem {
	res, err := c.TokensOfExpanded(owner, 10)
	die(err)

	var list []NFTItem
	for _, re := range res {
		prop, err := c.Properties(re)
		die(err)

		list = append(list, parseMap(prop.Value().([]stackitem.MapElement)))
	}

	return list
}

func printMarketNFT(c *nftmarket.Contract) {
	res := listMarketNFT(c)
	fmt.Println("market nfts:")
	fmt.Println(res)
	fmt.Println()
}

func listMarketNFT(c *nftmarket.Contract) []NFTItem {
	res, err := c.List()
	die(err)

	var list []NFTItem
	for _, re := range res {
		items := re.Value().([]stackitem.MapElement)
		list = append(list, parseMap(items))
	}

	return list
}

type NFTItem struct {
	ID         []byte
	Owner      util.Uint160
	Name       string
	PrevOwners int
	Created    int
	Bought     int
}

func (n NFTItem) String() string {
	return fmt.Sprintf("%x\nowner: %s\nname: %s\nprevOwners: %d\ncreated block: %d\nlast bought block: %d\n",
		n.ID, address.Uint160ToString(n.Owner), n.Name, n.PrevOwners, n.Created, n.Bought)
}

func parseMap(items []stackitem.MapElement) NFTItem {
	var res NFTItem

	for _, item := range items {
		k, err := item.Key.TryBytes()
		die(err)
		v, err := item.Value.TryBytes()
		die(err)

		kStr := string(k)

		switch kStr {
		case "id":
			res.ID = v
		case "owner":
			res.Owner, err = address.StringToUint160(string(v))
			die(err)
		case "name":
			res.Name = string(v)
		case "preOwners":
			res.PrevOwners, err = strconv.Atoi(string(v))
			die(err)
		case "created":
			res.Created, err = strconv.Atoi(string(v))
			die(err)
		case "bought":
			res.Bought, err = strconv.Atoi(string(v))
			die(err)
		}
	}

	return res
}

func die(err error) {
	if err == nil {
		return
	}

	debug.PrintStack()
	_, _ = fmt.Fprintf(os.Stderr, "Error: %v\n", err)
	os.Exit(1)
}