package testutil

import (
	"context"
	"fmt"
	"math/big"
	"testing"

	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/stretchr/testify/assert"
	"github.com/synapsecns/sanguine/ethergo/backends"
	"github.com/synapsecns/sanguine/ethergo/contracts"
	"github.com/synapsecns/sanguine/ethergo/deployer"
	"github.com/synapsecns/sanguine/ethergo/manager"
	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridge"
	"github.com/synapsecns/sanguine/services/rfq/contracts/testcontracts/fastbridgemock"
)

// DeployManager wraps DeployManager and allows typed contract handles to be returned.
type DeployManager struct {
	*manager.DeployerManager
}

// NewDeployManager creates a new DeployManager.
func NewDeployManager(t *testing.T) *DeployManager {
	t.Helper()

	parentManager := manager.NewDeployerManager(t, NewFastBridgeDeployer, NewMockERC20Deployer, NewMockFastBridgeDeployer, NewWETH9Deployer, NewUSDTDeployer, NewUSDCDeployer, NewDAIDeployer)
	return &DeployManager{parentManager}
}

// MintToAddress mints an equal amount of tokens to an address. Amount is multiplied by decimals to ensure events.
func (d *DeployManager) MintToAddress(ctx context.Context, backend backends.SimulatedTestBackend, token contracts.ContractType, mintToAddress common.Address, amount *big.Int) (adjustedAmount *big.Int) {
	d.T().Helper()

	//nolint: exhaustive
	switch token {
	case DAIType:
		contract, handle := d.GetDAI(ctx, backend)

		auth := backend.GetTxContext(ctx, contract.OwnerPtr())
		adjustedAmount = MustAdjustAmount(ctx, d.T(), amount, handle)

		tx, err := handle.Mint(auth.TransactOpts, mintToAddress, adjustedAmount)
		assert.NoError(d.T(), err)

		backend.WaitForConfirmation(ctx, tx)
	case USDTType:
		contract, handle := d.GetUSDT(ctx, backend)

		adjustedAmount = MustAdjustAmount(ctx, d.T(), amount, handle)

		auth := backend.GetTxContext(ctx, contract.OwnerPtr())
		tx, err := handle.Redeem(auth.TransactOpts, adjustedAmount)
		assert.NoError(d.T(), err)

		backend.WaitForConfirmation(ctx, tx)

		auth = backend.GetTxContext(ctx, contract.OwnerPtr())
		tx, err = handle.Transfer(auth.TransactOpts, mintToAddress, adjustedAmount)
		assert.NoError(d.T(), err)

		backend.WaitForConfirmation(ctx, tx)

	case USDCType:
		contract, handle := d.GetUSDC(ctx, backend)

		adjustedAmount = MustAdjustAmount(ctx, d.T(), amount, handle)

		auth := backend.GetTxContext(ctx, contract.OwnerPtr())
		// TODO: it's fairly likely we should just configure this w/ max mint rights to minter
		tx, err := handle.ConfigureMinter(auth.TransactOpts, contract.Owner(), adjustedAmount)
		assert.NoError(d.T(), err)
		backend.WaitForConfirmation(ctx, tx)
		fmt.Printf("minter configured: %s \n ", tx.Hash())

		auth = backend.GetTxContext(ctx, contract.OwnerPtr())
		tx, err = handle.Mint(auth.TransactOpts, mintToAddress, adjustedAmount)
		assert.NoError(d.T(), err)

		backend.WaitForConfirmation(ctx, tx)
	case MockERC20Type:
		contract, handle := d.GetMockERC20(ctx, backend)
		adjustedAmount = MustAdjustAmount(ctx, d.T(), amount, handle)

		auth := backend.GetTxContext(ctx, contract.OwnerPtr())

		tx, err := handle.Mint(auth.TransactOpts, mintToAddress, adjustedAmount)
		assert.NoError(d.T(), err)

		backend.WaitForConfirmation(ctx, tx)
	default:
		d.T().Errorf("contract type %s not (yet) supported", token.Name())
	}

	return adjustedAmount
}

// FastBridgeDeployer deplyos a fast bridge contract for testing.
type FastBridgeDeployer struct {
	*deployer.BaseDeployer
}

// NewFastBridgeDeployer deploys a fast bridge contract.
func NewFastBridgeDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return FastBridgeDeployer{
		deployer.NewSimpleDeployer(registry, backend, FastBridgeType),
	}
}

// Deploy deploys the fast bridge contract.
func (f FastBridgeDeployer) Deploy(ctx context.Context) (contracts.DeployedContract, error) {
	return f.DeploySimpleContract(ctx, func(transactOps *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, interface{}, error) {
		return fastbridge.DeployFastBridge(transactOps, backend, transactOps.From)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return fastbridge.NewFastBridgeRef(address, backend)
	})
}

// MockFastBridgeDeployer deploys a mock fast bridge contract for testing.
type MockFastBridgeDeployer struct {
	*deployer.BaseDeployer
}

// NewMockFastBridgeDeployer deploys a mock fast bridge contract.
func NewMockFastBridgeDeployer(registry deployer.GetOnlyContractRegistry, backend backends.SimulatedTestBackend) deployer.ContractDeployer {
	return MockFastBridgeDeployer{
		deployer.NewSimpleDeployer(registry, backend, FastBridgeMockType),
	}
}

// Deploy deploys the mock fast bridge contract.
func (m MockFastBridgeDeployer) 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 fastbridgemock.DeployFastBridgeMock(transactOps, backend, transactOps.From)
	}, func(address common.Address, backend bind.ContractBackend) (interface{}, error) {
		return fastbridgemock.NewFastBridgeMockRef(address, backend)
	})
}