package transfer

import (
	"database/sql"
	"fmt"
	"strings"

	"github.com/ethereum/go-ethereum/common"
	wallet_common "github.com/status-im/status-go/services/wallet/common"
)

// Since we already use MultitransactionIDType in DB, and its default value is 0 (Send)
// this type is used to with default value 0 to represent invalid type to avoid bugs
// when devs forget to call NewMultiTxDetails()
type MultiTransactionDBType MultiTransactionType

const (
	MultiTransactionDBTypeInvalid = 0
	MultiTransactionDBSend        = iota
	MultiTransactionDBSwap
	MultiTransactionDBBridge
	MultiTransactionDBApprove
)

func mtDBTypeToMTType(mtDBType MultiTransactionDBType) MultiTransactionType {
	if mtDBType == MultiTransactionDBTypeInvalid {
		return MultiTransactionTypeInvalid
	}

	return MultiTransactionType(mtDBType - 1)
}

type MultiTxDetails struct {
	IDs         []wallet_common.MultiTransactionIDType
	AnyAddress  common.Address
	FromAddress common.Address
	ToAddress   common.Address
	ToChainID   uint64
	CrossTxID   string
	Type        MultiTransactionDBType
}

func NewMultiTxDetails() *MultiTxDetails {
	return &MultiTxDetails{}
}

type MultiTransactionDB struct {
	db *sql.DB
}

func NewMultiTransactionDB(db *sql.DB) *MultiTransactionDB {
	return &MultiTransactionDB{
		db: db,
	}
}

func (mtDB *MultiTransactionDB) CreateMultiTransaction(multiTransaction *MultiTransaction) error {
	insert, err := mtDB.db.Prepare(fmt.Sprintf(`INSERT INTO multi_transactions (%s)
											VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, multiTransactionColumns))
	if err != nil {
		return err
	}
	_, err = insert.Exec(
		multiTransaction.ID,
		multiTransaction.FromNetworkID,
		multiTransaction.FromTxHash,
		multiTransaction.FromAddress,
		multiTransaction.FromAsset,
		multiTransaction.FromAmount.String(),
		multiTransaction.ToNetworkID,
		multiTransaction.ToTxHash,
		multiTransaction.ToAddress,
		multiTransaction.ToAsset,
		multiTransaction.ToAmount.String(),
		multiTransaction.Type,
		multiTransaction.CrossTxID,
		multiTransaction.Timestamp,
	)
	if err != nil {
		return err
	}
	defer insert.Close()

	return err
}

func (mtDB *MultiTransactionDB) ReadMultiTransactions(details *MultiTxDetails) ([]*MultiTransaction, error) {
	if details == nil {
		return nil, fmt.Errorf("details is nil")
	}

	whereClause := ""

	args := []interface{}{}

	if len(details.IDs) > 0 {
		placeholders := make([]string, len(details.IDs))
		for i, v := range details.IDs {
			placeholders[i] = "?"
			args = append(args, v)
		}
		whereClause += fmt.Sprintf("id in (%s) AND ", strings.Join(placeholders, ","))
	}
	if (details.AnyAddress != common.Address{}) {
		whereClause += "(from_address=? OR to_address=?) AND "
		args = append(args, details.AnyAddress, details.AnyAddress)
	}
	if (details.FromAddress != common.Address{}) {
		whereClause += "from_address=? AND "
		args = append(args, details.FromAddress)
	}
	if (details.ToAddress != common.Address{}) {
		whereClause += "to_address=? AND "
		args = append(args, details.ToAddress)
	}
	if details.ToChainID != 0 {
		whereClause += "to_network_id=? AND "
		args = append(args, details.ToChainID)
	}
	if details.CrossTxID != "" {
		whereClause += "cross_tx_id=? AND "
		args = append(args, details.CrossTxID)
	}
	if details.Type != MultiTransactionDBTypeInvalid {
		whereClause += "type=? AND "
		args = append(args, mtDBTypeToMTType(details.Type))
	}

	stmt, err := mtDB.db.Prepare(fmt.Sprintf(`SELECT %s
											FROM multi_transactions
											WHERE %s`,
		selectMultiTransactionColumns, whereClause[:len(whereClause)-5]))
	if err != nil {
		return nil, err
	}
	defer stmt.Close()

	rows, err := stmt.Query(args...)
	if err != nil {
		return nil, err
	}
	defer rows.Close()

	return rowsToMultiTransactions(rows)
}

func (mtDB *MultiTransactionDB) UpdateMultiTransaction(multiTransaction *MultiTransaction) error {
	if multiTransaction.ID == wallet_common.NoMultiTransactionID {
		return fmt.Errorf("no multitransaction ID")
	}

	update, err := mtDB.db.Prepare(fmt.Sprintf(`REPLACE INTO multi_transactions (%s)
	VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, multiTransactionColumns))

	if err != nil {
		return err
	}
	_, err = update.Exec(
		multiTransaction.ID,
		multiTransaction.FromNetworkID,
		multiTransaction.FromTxHash,
		multiTransaction.FromAddress,
		multiTransaction.FromAsset,
		multiTransaction.FromAmount.String(),
		multiTransaction.ToNetworkID,
		multiTransaction.ToTxHash,
		multiTransaction.ToAddress,
		multiTransaction.ToAsset,
		multiTransaction.ToAmount.String(),
		multiTransaction.Type,
		multiTransaction.CrossTxID,
		multiTransaction.Timestamp,
	)
	if err != nil {
		return err
	}
	return update.Close()
}

func (mtDB *MultiTransactionDB) DeleteMultiTransaction(id wallet_common.MultiTransactionIDType) error {
	_, err := mtDB.db.Exec(`DELETE FROM multi_transactions WHERE id=?`, id)
	return err
}