package wallet

import (
	"crypto/ecdsa"
	"fmt"
	"github.com/synapsecns/sanguine/core"
	"os"
	"strings"

	"github.com/ethereum/go-ethereum/accounts"
	"github.com/ethereum/go-ethereum/crypto"
	hdwallet "github.com/miguelmota/go-ethereum-hdwallet"
	"github.com/tyler-smith/go-bip39"
)

// FromPrivateKey creates a new wallet from a private key.
func FromPrivateKey(privKey *ecdsa.PrivateKey) (Wallet, error) {
	var account walletImpl

	account.privateKey = privKey
	pubKey := privKey.Public()
	pubKeyEcdsa, ok := pubKey.(*ecdsa.PublicKey)
	if !ok {
		return account, fmt.Errorf("unable to cast public key of type %T to *ecdsa.PublicKey", pubKey)
	}

	accountAddr := crypto.PubkeyToAddress(*pubKeyEcdsa)

	return &walletImpl{
		address:    accountAddr,
		privateKey: privKey,
		publicKey:  pubKeyEcdsa,
	}, nil
}

// FromKeyFile creates a wallet from a file. The wallet detects if this is a
// seed phrase or a private key hex and returns the appropriate wallet. An error is
// returned if this cannot be determined.
//
// Currently, the default derivation path is used. This should be compatible with metamask
// and most wallets. It gets the first wallet in this derivation path.
// TODO: support json files.
func FromKeyFile(keyFile string) (Wallet, error) {
	//nolint:gosec
	rawKey, err := os.ReadFile(core.ExpandOrReturnPath(keyFile))
	if err != nil {
		return nil, fmt.Errorf("could not get seed phrase: %w", err)
	}
	key := strings.TrimSpace(string(rawKey))

	// if it's a mnemonic use that
	if bip39.IsMnemonicValid(key) {
		return FromSeedPhrase(key, accounts.DefaultBaseDerivationPath)
	}

	return FromHex(key)
}

// FromHex gets the wallet from the private key.
func FromHex(privateKey string) (Wallet, error) {
	// Check for '0x' prefix and remove it if it exists
	if len(privateKey) >= 2 && strings.EqualFold(privateKey[:2], "0x") {
		privateKey = privateKey[2:]
	}

	privKey, err := crypto.HexToECDSA(privateKey)
	if err != nil {
		return nil, fmt.Errorf("could not decode key: %w", err)
	}
	return FromPrivateKey(privKey)
}

// FromSeedPhrase gets the seed phrase for the wallet.
// Note: there seems to be some issue here w/ longer seed phraeses should investigate.
func FromSeedPhrase(seedPhrase string, derivationPath accounts.DerivationPath) (Wallet, error) {
	wallet, err := hdwallet.NewFromMnemonic(seedPhrase)
	if err != nil {
		return nil, fmt.Errorf("could not get parse phrase: %w", err)
	}

	wallet.SetFixIssue172(true)

	account, err := wallet.Derive(derivationPath, true)
	if err != nil {
		return nil, fmt.Errorf("could not derive account: %w", err)
	}

	privKey, err := wallet.PrivateKey(account)
	if err != nil {
		return nil, fmt.Errorf("could not get private key: %w", err)
	}
	return FromPrivateKey(privKey)
}

// FromRandom generates a new private key. Note: this should be used for testing only and has not been audited yet.
func FromRandom() (Wallet, error) {
	newSeed, err := hdwallet.NewSeed()
	if err != nil {
		return nil, fmt.Errorf("could not generate seed: %w", err)
	}

	newWallet, err := hdwallet.NewFromSeed(newSeed)
	if err != nil {
		return nil, fmt.Errorf("could not use seed: %w", err)
	}

	account, err := newWallet.Derive(accounts.DefaultBaseDerivationPath, true)
	if err != nil {
		return nil, fmt.Errorf("could not use derive account at %s: %w", accounts.DefaultBaseDerivationPath, err)
	}

	privKey, err := newWallet.PrivateKey(account)
	if err != nil {
		return nil, fmt.Errorf("could not get private key: %w", err)
	}

	return FromPrivateKey(privKey)
}