package testutil

import (
	"context"
	"fmt"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/synapsecns/sanguine/ethergo/backends"
	"github.com/synapsecns/sanguine/ethergo/contracts"
	"github.com/synapsecns/sanguine/ethergo/deployer"
	"github.com/synapsecns/sanguine/services/rfq/contracts/testcontracts/dai"
	mockerc202 "github.com/synapsecns/sanguine/services/rfq/contracts/testcontracts/mockerc20"
	"github.com/synapsecns/sanguine/services/rfq/contracts/testcontracts/usdc"
	"github.com/synapsecns/sanguine/services/rfq/contracts/testcontracts/usdt"
	"github.com/synapsecns/sanguine/services/rfq/contracts/testcontracts/weth9"
	"math/big"
)

// MockERC20Deployer deploys a mock erc20 contract.
type MockERC20Deployer struct {
	*deployer.BaseDeployer
}

// NewMockERC20Deployer creates a new mock erc20 deployer.
func NewMockERC20Deployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return MockERC20Deployer{
		deployer.NewSimpleDeployer(registry, backend, MockERC20Type),
	}
}

// MockERC20Decimals is the default number of mock erc20 decimals.
const MockERC20Decimals uint8 = 10

// MockERC20Name is the name of hte mock erc20.
const MockERC20Name = "token"

// Deploy deploys a mock erc20 contract.
func (m MockERC20Deployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return m.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return mockerc202.DeployMockERC20(transactOps, backend, MockERC20Name, MockERC20Decimals)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return mockerc202.NewMockerc20Ref(address, backend)
	})
}

// WETH9Deployer deploys a mock erc20 contract.
type WETH9Deployer struct {
	*deployer.BaseDeployer
}

// NewWETH9Deployer creates a new deployer for weth9.
func NewWETH9Deployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return WETH9Deployer{
		deployer.NewSimpleDeployer(registry, backend, WETH9Type),
	}
}

// Deploy deploys the weth9 contract.
func (m WETH9Deployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return m.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return weth9.DeployWETH9(transactOps, backend)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return weth9.NewWeth9Ref(address, backend)
	})
}

// USDTDeployer deploys the usdt token (https://tether.to/) for testing.
type USDTDeployer struct {
	*deployer.BaseDeployer
}

var defaultTetherInitialSupply = big.NewInt(1e6 * 50000000000)

// NewUSDTDeployer creates a new deployer for tether.
func NewUSDTDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return USDTDeployer{deployer.NewSimpleDeployer(registry, backend, USDTType)}
}

// Deploy deploys the usdt token.
func (d USDTDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return d.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return usdt.DeployTetherToken(transactOps, backend, defaultTetherInitialSupply, "Tether USD", "USDT", big.NewInt(6))
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return usdt.NewUSDTRef(address, backend)
	})
}

// USDCDeployer deploys the usdc token (https://www.centre.io/usdc) for testing.
type USDCDeployer struct {
	*deployer.BaseDeployer
}

// NewUSDCDeployer creates a new deployer for tether.
func NewUSDCDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return USDCDeployer{deployer.NewSimpleDeployer(registry, backend, USDCType)}
}

// Deploy deploys the usdt token.
func (d USDCDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return d.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		tmpAddress, tx, handle, err := usdc.DeployFiatTokenV21(transactOps, backend)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not deploy usdc contract")
		}
		d.Backend().WaitForConfirmation(ctx, tx)

		auth := d.Backend().GetTxContext(ctx, &transactOps.From)

		// see https://etherscan.io/token/0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48#writeProxyContract
		initializedTx, err := handle.Initialize(auth.TransactOpts, "USDC Coin", "USDC", "USD", uint8(6), auth.From, auth.From, auth.From, auth.From)
		if err != nil {
			return common.Address{}, nil, nil, fmt.Errorf("could not initialize usdc contract")
		}
		d.Backend().WaitForConfirmation(ctx, initializedTx)
		return tmpAddress, tx, handle, nil
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return usdc.NewUSDCRef(address, backend)
	})
}

// DAIDeployer deploys a mock erc20 contract.
type DAIDeployer struct {
	*deployer.BaseDeployer
}

// NewDAIDeployer creates a new deployer for dai.
func NewDAIDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return DAIDeployer{
		deployer.NewSimpleDeployer(registry, backend, DAIType),
	}
}

// Deploy deploys the dai contract.
func (m DAIDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return m.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return dai.DeployDai(transactOps, backend, m.Backend().GetBigChainID())
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return dai.NewDaiRef(address, backend)
	})
}