package base

import (
	"errors"
	"fmt"
	"math/big"
	"time"

	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/common/hexutil"
	"github.com/synapsecns/sanguine/core/dbcommon"
	"github.com/synapsecns/sanguine/services/rfq/contracts/fastbridge"
	"github.com/synapsecns/sanguine/services/rfq/guard/guarddb"
)

func init() {
	namer := dbcommon.NewNamer(GetAllModels())
	statusFieldName = namer.GetConsistentName("Status")
	transactionIDFieldName = namer.GetConsistentName("TransactionID")
}

var (
	// statusFieldName is the status field name.
	statusFieldName string
	// transactionIDFieldName is the transactions id field name.
	transactionIDFieldName string
)

// PendingProvenModel is the primary event model.
type PendingProvenModel struct {
	// CreatedAt is the creation time
	CreatedAt time.Time
	// UpdatedAt is the update time
	UpdatedAt time.Time
	// Origin is the origin chain id
	Origin uint32
	// RelayerAddress is the address of the relayer that called prove()
	RelayerAddress string
	// TransactionID is the transaction id of the event
	TransactionID string `gorm:"column:transaction_id;primaryKey"`
	// TxHash is the hash of the relay transaction on destination
	TxHash string
	// Status is the status of the event
	Status guarddb.PendingProvenStatus `gorm:"column:status;index:idx_guard_status_name"`
	// BlockNumber is the block number of the event
	BlockNumber uint64
}

// FromPendingProven converts a quote request to an object that can be stored in the db.
func FromPendingProven(proven guarddb.PendingProven) PendingProvenModel {
	return PendingProvenModel{
		Origin:         proven.Origin,
		RelayerAddress: proven.RelayerAddress.Hex(),
		TransactionID:  hexutil.Encode(proven.TransactionID[:]),
		TxHash:         proven.TxHash.Hex(),
		Status:         proven.Status,
		BlockNumber:    proven.BlockNumber,
	}
}

// ToPendingProven converts a db object to a pending proven.
func (p PendingProvenModel) ToPendingProven() (*guarddb.PendingProven, error) {
	txID, err := hexutil.Decode(p.TransactionID)
	if err != nil {
		return nil, fmt.Errorf("could not get transaction id: %w", err)
	}

	transactionID, err := sliceToArray(txID)
	if err != nil {
		return nil, fmt.Errorf("could not convert transaction id: %w", err)
	}

	return &guarddb.PendingProven{
		Origin:         p.Origin,
		RelayerAddress: common.HexToAddress(p.RelayerAddress),
		TransactionID:  transactionID,
		TxHash:         common.HexToHash(p.TxHash),
		Status:         p.Status,
		BlockNumber:    p.BlockNumber,
	}, nil
}

// BridgeRequestModel is the primary event model.
type BridgeRequestModel struct {
	// CreatedAt is the creation time
	CreatedAt time.Time
	// UpdatedAt is the update time
	UpdatedAt time.Time
	// TransactionID is the transaction id of the event
	TransactionID string `gorm:"column:transaction_id;primaryKey"`
	// OriginChainID is the origin chain for the transactions
	OriginChainID uint32
	// DestChainID is the destination chain for the tx
	DestChainID uint32
	// OriginSender is the original sender
	OriginSender string
	// DestRecipient is the recipient of the destination tx
	DestRecipient string
	// OriginToken is the origin token address
	OriginToken string
	// DestToken is the destination token address
	DestToken string
	// OriginAmount is the origin amount stored for sorting.
	// This is not the source of truth, but is approximate
	OriginAmount string
	// DestAmount is the destination amount stored for sorting.
	DestAmount string
	// Deadline is the deadline for the relay
	Deadline time.Time `gorm:"index"`
	// OriginNonce is the nonce on the origin chain in the app.
	// this is not effected by the message.sender nonce.
	OriginNonce int `gorm:"index"`
	// RawRequest is the raw request, hex encoded.
	RawRequest string
	// SendChainGas is true if the chain should send gas
	SendChainGas bool
}

// FromBridgeRequest converts a bridge request object to db model.
func FromBridgeRequest(request guarddb.BridgeRequest) BridgeRequestModel {
	return BridgeRequestModel{
		TransactionID: hexutil.Encode(request.TransactionID[:]),
		OriginChainID: request.Transaction.OriginChainId,
		DestChainID:   request.Transaction.DestChainId,
		OriginSender:  request.Transaction.OriginSender.String(),
		DestRecipient: request.Transaction.DestRecipient.String(),
		OriginToken:   request.Transaction.OriginToken.String(),
		RawRequest:    hexutil.Encode(request.RawRequest),
		SendChainGas:  request.Transaction.SendChainGas,
		DestToken:     request.Transaction.DestToken.String(),
		OriginAmount:  request.Transaction.OriginAmount.String(),
		DestAmount:    request.Transaction.DestAmount.String(),
		Deadline:      time.Unix(int64(request.Transaction.Deadline.Uint64()), 0),
		OriginNonce:   int(request.Transaction.Nonce.Uint64()),
	}
}

// ToBridgeRequest converts the bridge request db model to object.
func (b BridgeRequestModel) ToBridgeRequest() (*guarddb.BridgeRequest, error) {
	txID, err := hexutil.Decode(b.TransactionID)
	if err != nil {
		return nil, fmt.Errorf("could not get transaction id: %w", err)
	}

	req, err := hexutil.Decode(b.RawRequest)
	if err != nil {
		return nil, fmt.Errorf("could not get request: %w", err)
	}

	transactionID, err := sliceToArray(txID)
	if err != nil {
		return nil, fmt.Errorf("could not convert transaction id: %w", err)
	}

	originAmount, ok := new(big.Int).SetString(b.OriginAmount, 10)
	if !ok {
		return nil, errors.New("could not convert origin amount")
	}
	destAmount, ok := new(big.Int).SetString(b.DestAmount, 10)
	if !ok {
		return nil, errors.New("could not convert dest amount")
	}

	return &guarddb.BridgeRequest{
		TransactionID: transactionID,
		RawRequest:    req,
		Transaction: fastbridge.IFastBridgeBridgeTransaction{
			OriginChainId: b.OriginChainID,
			DestChainId:   b.DestChainID,
			OriginSender:  common.HexToAddress(b.OriginSender),
			DestRecipient: common.HexToAddress(b.DestRecipient),
			OriginToken:   common.HexToAddress(b.OriginToken),
			SendChainGas:  b.SendChainGas,
			DestToken:     common.HexToAddress(b.DestToken),
			OriginAmount:  originAmount,
			DestAmount:    destAmount,
			Deadline:      big.NewInt(b.Deadline.Unix()),
			Nonce:         big.NewInt(int64(b.OriginNonce)),
		},
	}, nil
}

func sliceToArray(slice []byte) ([32]byte, error) {
	var arr [32]byte
	if len(slice) != 32 {
		return arr, errors.New("slice is not 32 bytes long")
	}
	copy(arr[:], slice)
	return arr, nil
}