package fakes

import (
	"context"
	"math/big"

	"github.com/ethereum/go-ethereum"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core/types"
	"github.com/ethereum/go-ethereum/rpc"
	. "github.com/onsi/gomega"
)

type MockEthClient struct {
	callContractErr             error
	callContractPassedContext   context.Context
	callContractPassedMsg       ethereum.CallMsg
	callContractPassedNumber    *big.Int
	callContractReturnBytes     []byte
	blockByNumberErr            error
	blockByNumberPassedContext  context.Context
	blockByNumberPassedNumber   *big.Int
	blockByNumberReturnBlock    *types.Block
	headerByNumberErr           error
	headerByNumberPassedContext context.Context
	headerByNumberPassedNumber  *big.Int
	headerByNumberReturnHeader  *types.Header
	headerByNumbersReturnHeader []*types.Header
	headerByNumbersPassedNumber []*big.Int
	filterLogsErr               error
	filterLogsPassedContext     context.Context
	filterLogsPassedQuery       ethereum.FilterQuery
	filterLogsReturnLogs        []types.Log
	transactionReceipts         map[string]*types.Receipt
	err                         error
	passedBatch                 []rpc.BatchElem
	passedMethod                string
	transactionSenderErr        error
	transactionReceiptErr       error
}

func NewMockEthClient() *MockEthClient {
	return &MockEthClient{
		callContractErr:             nil,
		callContractPassedContext:   nil,
		callContractPassedMsg:       ethereum.CallMsg{},
		callContractPassedNumber:    nil,
		callContractReturnBytes:     nil,
		blockByNumberErr:            nil,
		blockByNumberPassedContext:  nil,
		blockByNumberPassedNumber:   nil,
		blockByNumberReturnBlock:    nil,
		headerByNumberErr:           nil,
		headerByNumberPassedContext: nil,
		headerByNumberPassedNumber:  nil,
		headerByNumberReturnHeader:  nil,
		filterLogsErr:               nil,
		filterLogsPassedContext:     nil,
		filterLogsPassedQuery:       ethereum.FilterQuery{},
		filterLogsReturnLogs:        nil,
		transactionReceipts:         make(map[string]*types.Receipt),
		err:                         nil,
		passedBatch:                 nil,
		passedMethod:                "123",
	}
}

func (client *MockEthClient) SetCallContractErr(err error) {
	client.callContractErr = err
}

func (client *MockEthClient) SetCallContractReturnBytes(returnBytes []byte) {
	client.callContractReturnBytes = returnBytes
}

func (client *MockEthClient) SetBlockByNumberErr(err error) {
	client.blockByNumberErr = err
}

func (client *MockEthClient) SetBlockByNumberReturnBlock(block *types.Block) {
	client.blockByNumberReturnBlock = block
}

func (client *MockEthClient) SetHeaderByNumberErr(err error) {
	client.headerByNumberErr = err
}

func (client *MockEthClient) SetHeaderByNumberReturnHeader(header *types.Header) {
	client.headerByNumberReturnHeader = header
}

func (client *MockEthClient) SetHeaderByNumbersReturnHeader(headers []*types.Header) {
	client.headerByNumbersReturnHeader = headers
}

func (client *MockEthClient) SetFilterLogsErr(err error) {
	client.filterLogsErr = err
}

func (client *MockEthClient) SetFilterLogsReturnLogs(logs []types.Log) {
	client.filterLogsReturnLogs = logs
}

func (client *MockEthClient) SetTransactionReceiptErr(err error) {
	client.transactionReceiptErr = err
}

func (client *MockEthClient) SetTransactionReceipts(receipts []*types.Receipt) {
	for _, receipt := range receipts {
		client.transactionReceipts[receipt.TxHash.Hex()] = receipt
	}
}

func (client *MockEthClient) SetTransactionSenderErr(err error) {
	client.transactionSenderErr = err
}

func (client *MockEthClient) CallContract(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
	client.callContractPassedContext = ctx
	client.callContractPassedMsg = msg
	client.callContractPassedNumber = blockNumber
	return client.callContractReturnBytes, client.callContractErr
}

func (client *MockEthClient) BatchCall(batch []rpc.BatchElem) error {
	client.passedBatch = batch
	client.passedMethod = batch[0].Method

	return nil
}

func (client *MockEthClient) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) {
	client.blockByNumberPassedContext = ctx
	client.blockByNumberPassedNumber = number
	return client.blockByNumberReturnBlock, client.blockByNumberErr
}

func (client *MockEthClient) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) {
	client.headerByNumberPassedContext = ctx
	client.headerByNumberPassedNumber = number
	return client.headerByNumberReturnHeader, client.headerByNumberErr
}

func (client *MockEthClient) HeaderByNumbers(numbers []*big.Int) ([]*types.Header, error) {
	client.headerByNumbersPassedNumber = numbers
	return client.headerByNumbersReturnHeader, client.headerByNumberErr
}

func (client *MockEthClient) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) {
	client.filterLogsPassedContext = ctx
	client.filterLogsPassedQuery = q
	return client.filterLogsReturnLogs, client.filterLogsErr
}

func (client *MockEthClient) TransactionSender(ctx context.Context, tx *types.Transaction, block common.Hash, index uint) (common.Address, error) {
	return common.HexToAddress("0x123"), client.transactionSenderErr
}

func (client *MockEthClient) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) {
	if gasUsed, ok := client.transactionReceipts[txHash.Hex()]; ok {
		return gasUsed, client.transactionReceiptErr
	}
	return &types.Receipt{GasUsed: uint64(0)}, client.transactionReceiptErr
}

func (client *MockEthClient) AssertCallContractCalledWith(ctx context.Context, msg ethereum.CallMsg, blockNumber *big.Int) {
	Expect(client.callContractPassedContext).To(Equal(ctx))
	Expect(client.callContractPassedMsg).To(Equal(msg))
	Expect(client.callContractPassedNumber).To(Equal(blockNumber))
}

func (client *MockEthClient) AssertBlockByNumberCalledWith(ctx context.Context, number *big.Int) {
	Expect(client.blockByNumberPassedContext).To(Equal(ctx))
	Expect(client.blockByNumberPassedNumber).To(Equal(number))
}

func (client *MockEthClient) AssertHeaderByNumberCalledWith(ctx context.Context, number *big.Int) {
	Expect(client.headerByNumberPassedContext).To(Equal(ctx))
	Expect(client.headerByNumberPassedNumber).To(Equal(number))
}

func (client *MockEthClient) AssertHeaderByNumbersCalledWith(number []*big.Int) {
	Expect(client.headerByNumbersPassedNumber).To(Equal(number))
}

func (client *MockEthClient) AssertFilterLogsCalledWith(ctx context.Context, q ethereum.FilterQuery) {
	Expect(client.filterLogsPassedContext).To(Equal(ctx))
	Expect(client.filterLogsPassedQuery).To(Equal(q))
}

func (client *MockEthClient) AssertBatchCalledWith(method string) {
	Expect(client.passedMethod).To(Equal(method))
}