package pathprocessor

import (
	"context"
	"math/big"
	"strconv"
	"sync"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/hexutil"
	ethTypes "github.com/ethereum/go-ethereum/core/types"
	"github.com/status-im/status-go/account"
	"github.com/status-im/status-go/eth-node/types"
	"github.com/status-im/status-go/rpc"
	walletCommon "github.com/status-im/status-go/services/wallet/common"
	"github.com/status-im/status-go/services/wallet/thirdparty/paraswap"
	walletToken "github.com/status-im/status-go/services/wallet/token"
	"github.com/status-im/status-go/transactions"
)

type SwapParaswapTxArgs struct {
	transactions.SendTxArgs
	ChainID            uint64  `json:"chainId"`
	ChainIDTo          uint64  `json:"chainIdTo"`
	TokenIDFrom        string  `json:"tokenIdFrom"`
	TokenIDTo          string  `json:"tokenIdTo"`
	SlippagePercentage float32 `json:"slippagePercentage"`
}

type SwapParaswapProcessor struct {
	paraswapClient *paraswap.ClientV5
	transactor     transactions.TransactorIface
	priceRoute     sync.Map // [fromChainName-toChainName-fromTokenSymbol-toTokenSymbol, paraswap.Route]
}

const (
	partnerID = "status.app"
)

func getPartnerAddressAndFeePcnt(chainID uint64) (common.Address, float64) {
	const partnerFeePcnt = 0.7

	switch chainID {
	case walletCommon.EthereumMainnet:
		return common.HexToAddress("0xd9abc564bfabefa88a6C2723d78124579600F568"), partnerFeePcnt
	case walletCommon.OptimismMainnet:
		return common.HexToAddress("0xE9B59dC0b30cd4646430c25de0111D651c395775"), partnerFeePcnt
	case walletCommon.ArbitrumMainnet:
		return common.HexToAddress("0x9a8278e856C0B191B9daa2d7DD1f7B28268E4DA2"), partnerFeePcnt
	}
	return common.Address{}, 0
}

func NewSwapParaswapProcessor(rpcClient *rpc.Client, transactor transactions.TransactorIface, tokenManager *walletToken.Manager) *SwapParaswapProcessor {
	defaultChainID := walletCommon.EthereumMainnet
	partnerAddress, partnerFeePcnt := getPartnerAddressAndFeePcnt(defaultChainID)

	return &SwapParaswapProcessor{
		paraswapClient: paraswap.NewClientV5(
			defaultChainID,
			partnerID,
			partnerAddress,
			partnerFeePcnt,
		),
		transactor: transactor,
		priceRoute: sync.Map{},
	}
}

func createSwapParaswapErrorResponse(err error) error {
	switch err.Error() {
	case "Price Timeout":
		return ErrPriceTimeout
	case "No routes found with enough liquidity":
		return ErrNotEnoughLiquidity
	}
	return createErrorResponse(ProcessorSwapParaswapName, err)
}

func (s *SwapParaswapProcessor) Name() string {
	return ProcessorSwapParaswapName
}

func (s *SwapParaswapProcessor) Clear() {
	s.priceRoute = sync.Map{}
}

func (s *SwapParaswapProcessor) AvailableFor(params ProcessorInputParams) (bool, error) {
	if params.FromChain == nil || params.ToChain == nil {
		return false, ErrNoChainSet
	}
	if params.FromToken == nil || params.ToToken == nil {
		return false, ErrToAndFromTokensMustBeSet
	}

	if params.FromChain.ChainID != params.ToChain.ChainID {
		return false, ErrFromAndToChainsMustBeSame
	}

	if params.FromToken.Symbol == params.ToToken.Symbol {
		return false, ErrFromAndToTokensMustBeDifferent
	}

	chainID := params.FromChain.ChainID
	partnerAddress, partnerFeePcnt := getPartnerAddressAndFeePcnt(chainID)
	s.paraswapClient.SetChainID(chainID)
	s.paraswapClient.SetPartnerAddress(partnerAddress)
	s.paraswapClient.SetPartnerFeePcnt(partnerFeePcnt)

	searchForToken := params.FromToken.Address == ZeroAddress
	searchForToToken := params.ToToken.Address == ZeroAddress
	if searchForToToken || searchForToken {
		tokensList, err := s.paraswapClient.FetchTokensList(context.Background())
		if err != nil {
			return false, createSwapParaswapErrorResponse(err)
		}

		for _, t := range tokensList {
			if searchForToken && t.Symbol == params.FromToken.Symbol {
				params.FromToken.Address = common.HexToAddress(t.Address)
				params.FromToken.Decimals = t.Decimals
				if !searchForToToken {
					break
				}
			}

			if searchForToToken && t.Symbol == params.ToToken.Symbol {
				params.ToToken.Address = common.HexToAddress(t.Address)
				params.ToToken.Decimals = t.Decimals
				if !searchForToken {
					break
				}
			}
		}
	}

	if params.FromToken.Address == ZeroAddress || params.ToToken.Address == ZeroAddress {
		return false, ErrCannotResolveTokens
	}

	return true, nil
}

func calcReceivedAmountAndFee(baseDestAmount *big.Int, feePcnt float64) (destAmount *big.Int, destFee *big.Int) {
	destAmount = new(big.Int).Set(baseDestAmount)
	destFee = new(big.Int).SetUint64(0)

	if feePcnt > 0 {
		baseDestAmountFloat := new(big.Float).SetInt(baseDestAmount)
		feePcntFloat := big.NewFloat(feePcnt / 100.0)

		destFeeFloat := new(big.Float).Set(baseDestAmountFloat)
		destFeeFloat = destFeeFloat.Mul(destFeeFloat, feePcntFloat)
		destFeeFloat.Int(destFee)

		destAmount = destAmount.Sub(destAmount, destFee)
	}
	return
}

func (s *SwapParaswapProcessor) CalculateFees(params ProcessorInputParams) (*big.Int, *big.Int, error) {
	return ZeroBigIntValue, ZeroBigIntValue, nil
}

func (s *SwapParaswapProcessor) PackTxInputData(params ProcessorInputParams) ([]byte, error) {
	// not sure what we can do here since we're using the api to build the transaction
	return []byte{}, nil
}

func (s *SwapParaswapProcessor) EstimateGas(params ProcessorInputParams) (uint64, error) {
	if params.TestsMode {
		if params.TestEstimationMap != nil {
			if val, ok := params.TestEstimationMap[s.Name()]; ok {
				return val, nil
			}
		}
		return 0, ErrNoEstimationFound
	}

	swapSide := paraswap.SellSide
	if params.AmountOut != nil && params.AmountOut.Cmp(ZeroBigIntValue) > 0 {
		swapSide = paraswap.BuySide
	}

	priceRoute, err := s.paraswapClient.FetchPriceRoute(context.Background(), params.FromToken.Address, params.FromToken.Decimals,
		params.ToToken.Address, params.ToToken.Decimals, params.AmountIn, params.FromAddr, params.ToAddr, swapSide)
	if err != nil {
		return 0, createSwapParaswapErrorResponse(err)
	}

	key := makeKey(params.FromChain.ChainID, params.ToChain.ChainID, params.FromToken.Symbol, params.ToToken.Symbol)
	s.priceRoute.Store(key, &priceRoute)

	return priceRoute.GasCost.Uint64(), nil
}

func (s *SwapParaswapProcessor) GetContractAddress(params ProcessorInputParams) (address common.Address, err error) {
	if params.FromChain.ChainID == walletCommon.EthereumMainnet {
		address = common.HexToAddress("0x216b4b4ba9f3e719726886d34a177484278bfcae")
	} else if params.FromChain.ChainID == walletCommon.ArbitrumMainnet {
		address = common.HexToAddress("0x216b4b4ba9f3e719726886d34a177484278bfcae")
	} else if params.FromChain.ChainID == walletCommon.OptimismMainnet {
		address = common.HexToAddress("0x216b4b4ba9f3e719726886d34a177484278bfcae")
	} else {
		err = ErrContractNotFound
	}
	return
}

func (s *SwapParaswapProcessor) BuildTx(params ProcessorInputParams) (*ethTypes.Transaction, error) {
	toAddr := types.Address(params.ToAddr)
	sendArgs := &MultipathProcessorTxArgs{
		SwapTx: &SwapParaswapTxArgs{
			SendTxArgs: transactions.SendTxArgs{
				From:   types.Address(params.FromAddr),
				To:     &toAddr,
				Value:  (*hexutil.Big)(params.AmountIn),
				Data:   types.HexBytes("0x0"),
				Symbol: params.FromToken.Symbol,
			},
			ChainID:     params.FromChain.ChainID,
			ChainIDTo:   params.ToChain.ChainID,
			TokenIDFrom: params.FromToken.Symbol,
			TokenIDTo:   params.ToToken.Symbol,
		},
	}

	return s.BuildTransaction(sendArgs)
}

func (s *SwapParaswapProcessor) prepareTransaction(sendArgs *MultipathProcessorTxArgs) error {
	slippageBP := uint(sendArgs.SwapTx.SlippagePercentage * 100) // convert to basis points

	key := makeKey(sendArgs.SwapTx.ChainID, sendArgs.SwapTx.ChainIDTo, sendArgs.SwapTx.TokenIDFrom, sendArgs.SwapTx.TokenIDTo)
	priceRouteIns, ok := s.priceRoute.Load(key)
	if !ok {
		return ErrPriceRouteNotFound
	}
	priceRoute := priceRouteIns.(*paraswap.Route)

	tx, err := s.paraswapClient.BuildTransaction(context.Background(), priceRoute.SrcTokenAddress, priceRoute.SrcTokenDecimals, priceRoute.SrcAmount.Int,
		priceRoute.DestTokenAddress, priceRoute.DestTokenDecimals, priceRoute.DestAmount.Int, slippageBP,
		common.Address(sendArgs.SwapTx.From), common.Address(*sendArgs.SwapTx.To),
		priceRoute.RawPriceRoute, priceRoute.Side)
	if err != nil {
		return createSwapParaswapErrorResponse(err)
	}

	value, ok := new(big.Int).SetString(tx.Value, 10)
	if !ok {
		return ErrConvertingAmountToBigInt
	}

	gas, err := strconv.ParseUint(tx.Gas, 10, 64)
	if err != nil {
		return createSwapParaswapErrorResponse(err)
	}

	gasPrice, ok := new(big.Int).SetString(tx.GasPrice, 10)
	if !ok {
		return ErrConvertingAmountToBigInt
	}

	sendArgs.ChainID = tx.ChainID
	sendArgs.SwapTx.ChainID = tx.ChainID
	toAddr := types.HexToAddress(tx.To)
	sendArgs.SwapTx.From = types.HexToAddress(tx.From)
	sendArgs.SwapTx.To = &toAddr
	sendArgs.SwapTx.Value = (*hexutil.Big)(value)
	sendArgs.SwapTx.Gas = (*hexutil.Uint64)(&gas)
	sendArgs.SwapTx.GasPrice = (*hexutil.Big)(gasPrice)
	sendArgs.SwapTx.Data = types.Hex2Bytes(tx.Data)

	return nil
}

func (s *SwapParaswapProcessor) BuildTransaction(sendArgs *MultipathProcessorTxArgs) (*ethTypes.Transaction, error) {
	err := s.prepareTransaction(sendArgs)
	if err != nil {
		return nil, createSwapParaswapErrorResponse(err)
	}
	return s.transactor.ValidateAndBuildTransaction(sendArgs.ChainID, sendArgs.SwapTx.SendTxArgs)
}

func (s *SwapParaswapProcessor) Send(sendArgs *MultipathProcessorTxArgs, verifiedAccount *account.SelectedExtKey) (types.Hash, error) {
	err := s.prepareTransaction(sendArgs)
	if err != nil {
		return types.Hash{}, createSwapParaswapErrorResponse(err)
	}

	return s.transactor.SendTransactionWithChainID(sendArgs.ChainID, sendArgs.SwapTx.SendTxArgs, verifiedAccount)
}

func (s *SwapParaswapProcessor) CalculateAmountOut(params ProcessorInputParams) (*big.Int, error) {
	key := makeKey(params.FromChain.ChainID, params.ToChain.ChainID, params.FromToken.Symbol, params.ToToken.Symbol)
	priceRouteIns, ok := s.priceRoute.Load(key)
	if !ok {
		return nil, ErrPriceRouteNotFound
	}
	priceRoute := priceRouteIns.(*paraswap.Route)

	_, partnerFeePcnt := getPartnerAddressAndFeePcnt(params.FromChain.ChainID)
	destAmount, _ := calcReceivedAmountAndFee(priceRoute.DestAmount.Int, partnerFeePcnt)

	return destAmount, nil
}