package sql

import (
	"context"
	"fmt"
	"github.com/benbjohnson/immutable"
	"github.com/synapsecns/sanguine/core"
	"github.com/synapsecns/sanguine/services/explorer/graphql/server/graph/model"
)

/*╔══════════════════════════════════════════════════════════════════════╗*\
▏*║                        Generic Read Functions                        ║*▕
\*╚══════════════════════════════════════════════════════════════════════╝*/

// GetUint64 gets a uint64 from a given query.
func (s *Store) GetUint64(ctx context.Context, query string) (uint64, error) {
	var res int64

	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return 0, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return uint64(res), nil
}

// GetFloat64 gets a float64 from a given query.
func (s *Store) GetFloat64(ctx context.Context, query string) (float64, error) {
	var res float64
	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return 0, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return res, nil
}

// GetString gets a string from a given query.
func (s *Store) GetString(ctx context.Context, query string) (string, error) {
	var res string
	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return "", fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return res, nil
}

// GetStringArray returns a string array for a given query.
func (s *Store) GetStringArray(ctx context.Context, query string) ([]string, error) {
	var res []string

	dbTx := s.db.WithContext(ctx).Raw(query + " SETTINGS readonly=1").Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return res, nil
}

// GetBridgeEvent returns a bridge event.
func (s *Store) GetBridgeEvent(ctx context.Context, query string) (*BridgeEvent, error) {
	var res BridgeEvent

	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return &res, nil
}

// GetMVBridgeEvent gets a bridge event from the materialized view table.
func (s *Store) GetMVBridgeEvent(ctx context.Context, query string) (*HybridBridgeEvent, error) {
	var res HybridBridgeEvent

	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return &res, nil
}

// GetBridgeEvents returns bridge events.
func (s *Store) GetBridgeEvents(ctx context.Context, query string) ([]BridgeEvent, error) {
	var res []BridgeEvent
	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return res, nil
}

// GetAllBridgeEvents returns bridge events.
func (s *Store) GetAllBridgeEvents(ctx context.Context, query string) ([]HybridBridgeEvent, error) {
	var res []HybridBridgeEvent
	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}
	return res, nil
}

// GetDailyTotals returns bridge events.
func (s *Store) GetDailyTotals(ctx context.Context, query string) ([]*model.DateResultByChain, error) {
	var res []*model.DateResultByChain

	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}
	return res, nil
}

// GetAllMessageBusEvents returns message bus events.
func (s *Store) GetAllMessageBusEvents(ctx context.Context, query string) ([]HybridMessageBusEvent, error) {
	var res []HybridMessageBusEvent
	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read message bus event: %w", dbTx.Error)
	}
	return res, nil
}

// GetTxCounts returns Tx counts.
func (s *Store) GetTxCounts(ctx context.Context, query string) ([]*model.TransactionCountResult, error) {
	var res []*model.TransactionCountResult
	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return res, nil
}

// GetTokenCounts returns Tx counts.
func (s *Store) GetTokenCounts(ctx context.Context, query string) ([]*model.TokenCountResult, error) {
	var res []*model.TokenCountResult
	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return res, nil
}

// GetRankedChainsByVolume gets ranked chains by volume.
func (s *Store) GetRankedChainsByVolume(ctx context.Context, query string) ([]*model.VolumeByChainID, error) {
	var res []*model.VolumeByChainID
	dbTx := s.db.WithContext(ctx).Raw(query).Find(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}

	return res, nil
}

// GetDateResults returns the dya by day data.
func (s *Store) GetDateResults(ctx context.Context, query string) ([]*model.DateResult, error) {
	var res []*model.DateResult
	dbTx := s.db.WithContext(ctx).Raw(query + " SETTINGS readonly=1").Scan(&res)

	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to get date results: %w", dbTx.Error)
	}

	return res, nil
}

// GetAddressData returns the address data.
func (s *Store) GetAddressData(ctx context.Context, query string) (float64, float64, int, error) {
	type addressData struct {
		VolumeTotal float64 `gorm:"column:volumeTotal"`
		FeeTotal    float64 `gorm:"column:feeTotal"`
		TxTotal     int     `gorm:"column:txTotal"`
	}
	var res addressData
	// var test map[string]interface{}
	dbTx := s.db.WithContext(ctx).Raw(query).Scan(&res)
	if dbTx.Error != nil {
		return 0, 0, 0, fmt.Errorf("failed to get address data: %w", dbTx.Error)
	}

	return res.VolumeTotal, res.FeeTotal, res.TxTotal, nil
}

// GetAddressChainRanking ranks chains by volume for a given address.
func (s *Store) GetAddressChainRanking(ctx context.Context, query string) ([]*model.AddressChainRanking, error) {
	var res []*model.AddressChainRanking
	dbTx := s.db.WithContext(ctx).Raw(query).Scan(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to get address chain ranking: %w", dbTx.Error)
	}

	return res, nil
}

// GetAddressDailyData gets daily data (number of txs_ for a given address.
func (s *Store) GetAddressDailyData(ctx context.Context, query string) ([]*model.AddressDailyCount, error) {
	var res []*model.AddressDailyCount
	dbTx := s.db.WithContext(ctx).Raw(query).Scan(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to get address daily data: %w", dbTx.Error)
	}

	return res, nil
}

// GetAddressRanking gets AddressRanking for a given query.
func (s *Store) GetAddressRanking(ctx context.Context, query string) ([]*model.AddressRanking, error) {
	var res []*model.AddressRanking

	dbTx := s.db.WithContext(ctx).Raw(query + " SETTINGS readonly=1").Scan(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to read bridge event: %w", dbTx.Error)
	}
	if len(res) == 0 {
		return nil, nil
	}

	return res, nil
}

// GetLastStoredBlock returns the last stored block for a given chainID and contract.
func (s *Store) GetLastStoredBlock(ctx context.Context, chainID uint32, contract string) (uint64, error) {
	query := fmt.Sprintf("SELECT %s FROM last_blocks WHERE %s = %d AND %s = '%s' ORDER BY %s DESC LIMIT 1", BlockNumberFieldName, ChainIDFieldName, chainID, ContractAddressFieldName, contract, BlockNumberFieldName)
	lastBlock, err := s.GetUint64(ctx, query)
	if err != nil {
		return 0, fmt.Errorf("failed to get last block: %w", err)
	}

	return lastBlock, nil
}

// GetLeaderboard gets the bridge leaderboard.
func (s *Store) GetLeaderboard(ctx context.Context, query string) ([]*model.Leaderboard, error) {
	var res []*model.Leaderboard
	dbTx := s.db.WithContext(ctx).Raw(query).Scan(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to get leaderboard: %w", dbTx.Error)
	}
	if len(res) == 0 {
		return nil, nil
	}

	return res, nil
}

// GetPendingByChain gets the bridge leaderboard by chain.
// returns chainid, count
// TODO: test this.
func (s *Store) GetPendingByChain(ctx context.Context) (res *immutable.Map[int, int], err error) {
	const query = `SELECT
		toInt64(destination_chain_id) as destination_chain_id,
		toInt64(COUNTDistinct(destination_kappa)) AS distinct_count
	FROM bridge_events
	WHERE destination_kappa NOT IN (
		SELECT kappa
		FROM bridge_events
		WHERE kappa != ''
	)
	GROUP BY destination_chain_id`

	type PendingByChain struct {
		DestinationChainID *int64 `gorm:"column:destination_chain_id"`
		DistinctCount      *int64 `gorm:"column:distinct_count"`
	}

	var pending []*PendingByChain

	dbTx := s.db.WithContext(ctx).Raw(query).Scan(&pending)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to get pending by chain: %w", dbTx.Error)
	}

	builder := immutable.NewMapBuilder[int, int](nil)

	for _, kvPair := range pending {
		builder.Set(int(*kvPair.DestinationChainID), int(*kvPair.DistinctCount))
	}

	return builder.Map(), nil
}

func (s *Store) GetBlockHeights(ctx context.Context, query string, contractTypeMap map[string]model.ContractType) ([]*model.BlockHeight, error) {
	var res []*LastBlock
	dbTx := s.db.WithContext(ctx).Raw(query).Scan(&res)
	if dbTx.Error != nil {
		return nil, fmt.Errorf("failed to get block heights: %w", dbTx.Error)
	}
	if len(res) == 0 {
		return nil, nil
	}

	var formatted []*model.BlockHeight
	for _, block := range res {
		chainID := int(block.ChainID)
		blockNumber := int(block.BlockNumber)
		formatted = append(formatted, &model.BlockHeight{
			ChainID:     &chainID,
			Type:        core.PtrTo(contractTypeMap[block.ContractAddress]),
			BlockNumber: &blockNumber,
		})
	}

	return formatted, nil
}