package main

import (
	"bytes"
	"context"
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"fmt"
	gobig "math/big"
	"strings"
	"sync"

	"github.com/ipfs/go-cid"
	"golang.org/x/xerrors"

	"github.com/filecoin-project/go-address"
	"github.com/filecoin-project/go-jsonrpc"
	"github.com/filecoin-project/go-state-types/big"
	"github.com/filecoin-project/go-state-types/crypto"

	"github.com/filecoin-project/lotus/api"
	"github.com/filecoin-project/lotus/api/v0api"
	"github.com/filecoin-project/lotus/chain/actors/builtin"
	"github.com/filecoin-project/lotus/chain/actors/builtin/multisig"
	"github.com/filecoin-project/lotus/chain/consensus"
	"github.com/filecoin-project/lotus/chain/types"
	lcli "github.com/filecoin-project/lotus/cli"
)

type InteractiveWallet struct {
	lk sync.Mutex

	apiGetter func() (v0api.FullNode, jsonrpc.ClientCloser, error)
	under     v0api.Wallet
}

func (c *InteractiveWallet) WalletNew(ctx context.Context, typ types.KeyType) (address.Address, error) {
	err := c.accept(func() error {
		fmt.Println("-----")
		fmt.Println("ACTION: WalletNew - Creating new wallet")
		fmt.Printf("TYPE: %s\n", typ)
		return nil
	})
	if err != nil {
		return address.Address{}, err
	}

	return c.under.WalletNew(ctx, typ)
}

func (c *InteractiveWallet) WalletHas(ctx context.Context, addr address.Address) (bool, error) {
	return c.under.WalletHas(ctx, addr)
}

func (c *InteractiveWallet) WalletList(ctx context.Context) ([]address.Address, error) {
	return c.under.WalletList(ctx)
}

func (c *InteractiveWallet) WalletSign(ctx context.Context, k address.Address, msg []byte, meta api.MsgMeta) (*crypto.Signature, error) {
	err := c.accept(func() error {
		fmt.Println("-----")
		fmt.Println("ACTION: WalletSign - Sign a message/deal")
		fmt.Printf("ADDRESS: %s\n", k)
		fmt.Printf("TYPE: %s\n", meta.Type)

		switch meta.Type {
		case api.MTChainMsg:
			var cmsg types.Message
			if err := cmsg.UnmarshalCBOR(bytes.NewReader(meta.Extra)); err != nil {
				return xerrors.Errorf("unmarshalling message: %w", err)
			}

			_, bc, err := cid.CidFromBytes(msg)
			if err != nil {
				return xerrors.Errorf("getting cid from signing bytes: %w", err)
			}

			if !cmsg.Cid().Equals(bc) {
				return xerrors.Errorf("cid(meta.Extra).bytes() != msg")
			}

			jb, err := json.MarshalIndent(&cmsg, "", "  ")
			if err != nil {
				return xerrors.Errorf("json-marshaling the message: %w", err)
			}

			fmt.Println("Message JSON:", string(jb))

			fmt.Println("Value:", types.FIL(cmsg.Value))
			fmt.Println("Max Fees:", types.FIL(cmsg.RequiredFunds()))
			fmt.Println("Max Total Cost:", types.FIL(big.Add(cmsg.RequiredFunds(), cmsg.Value)))

			if c.apiGetter != nil {
				napi, closer, err := c.apiGetter()
				if err != nil {
					return xerrors.Errorf("getting node api: %w", err)
				}
				defer closer()

				toact, err := napi.StateGetActor(ctx, cmsg.To, types.EmptyTSK)
				if err != nil {
					return xerrors.Errorf("looking up dest actor: %w", err)
				}

				fmt.Println("Method:", consensus.NewActorRegistry().Methods[toact.Code][cmsg.Method].Name)
				p, err := lcli.JsonParams(toact.Code, cmsg.Method, cmsg.Params)
				if err != nil {
					return err
				}

				fmt.Println("Params:", p)

				if builtin.IsMultisigActor(toact.Code) && cmsg.Method == multisig.Methods.Propose {
					var mp multisig.ProposeParams
					if err := mp.UnmarshalCBOR(bytes.NewReader(cmsg.Params)); err != nil {
						return xerrors.Errorf("unmarshalling multisig propose params: %w", err)
					}

					fmt.Println("\tMultiSig Proposal Value:", types.FIL(mp.Value))
					fmt.Println("\tMultiSig Proposal Hex Params:", hex.EncodeToString(mp.Params))

					toact, err := napi.StateGetActor(ctx, mp.To, types.EmptyTSK)
					if err != nil {
						return xerrors.Errorf("looking up msig dest actor: %w", err)
					}

					fmt.Println("\tMultiSig Proposal Method:", consensus.NewActorRegistry().Methods[toact.Code][mp.Method].Name) // todo use remote
					p, err := lcli.JsonParams(toact.Code, mp.Method, mp.Params)
					if err != nil {
						return err
					}

					fmt.Println("\tMultiSig Proposal Params:", strings.ReplaceAll(p, "\n", "\n\t"))
				}
			} else {
				fmt.Println("Params: No chain node connection, can't decode params")
			}

		case api.MTDealProposal:
			return xerrors.Errorf("TODO") // TODO
		default:
			log.Infow("WalletSign", "address", k, "type", meta.Type)
		}

		return nil
	})
	if err != nil {
		return nil, err
	}

	return c.under.WalletSign(ctx, k, msg, meta)
}

func (c *InteractiveWallet) WalletExport(ctx context.Context, a address.Address) (*types.KeyInfo, error) {
	err := c.accept(func() error {
		fmt.Println("-----")
		fmt.Println("ACTION: WalletExport - Export private key")
		fmt.Printf("ADDRESS: %s\n", a)
		return nil
	})
	if err != nil {
		return nil, err
	}

	return c.under.WalletExport(ctx, a)
}

func (c *InteractiveWallet) WalletImport(ctx context.Context, ki *types.KeyInfo) (address.Address, error) {
	err := c.accept(func() error {
		fmt.Println("-----")
		fmt.Println("ACTION: WalletImport - Import private key")
		fmt.Printf("TYPE: %s\n", ki.Type)
		return nil
	})
	if err != nil {
		return address.Undef, err
	}

	return c.under.WalletImport(ctx, ki)
}

func (c *InteractiveWallet) WalletDelete(ctx context.Context, addr address.Address) error {
	err := c.accept(func() error {
		fmt.Println("-----")
		fmt.Println("ACTION: WalletDelete - Delete a private key")
		fmt.Printf("ADDRESS: %s\n", addr)
		return nil
	})
	if err != nil {
		return err
	}

	return c.under.WalletDelete(ctx, addr)
}

func (c *InteractiveWallet) accept(prompt func() error) error {
	c.lk.Lock()
	defer c.lk.Unlock()

	if err := prompt(); err != nil {
		return err
	}

	yes := randomYes()
	for {
		fmt.Printf("\nAccept the above? (%s/No): ", yes)
		var a string
		if _, err := fmt.Scanln(&a); err != nil {
			return err
		}
		switch a {
		case yes:
			fmt.Println("approved")
			return nil
		case "No":
			return xerrors.Errorf("action rejected")
		}

		fmt.Printf("Type EXACTLY '%s' or 'No'\n", yes)
	}
}

var yeses = []string{
	"yes",
	"Yes",
	"YES",
	"approve",
	"Approve",
	"accept",
	"Accept",
	"authorize",
	"Authorize",
	"confirm",
	"Confirm",
}

func randomYes() string {
	i, err := rand.Int(rand.Reader, gobig.NewInt(int64(len(yeses))))
	if err != nil {
		panic(err)
	}

	return yeses[i.Int64()]
}