// Package user defines all end-user defined messages we resolve to in the explorer
package user

import (
	"context"
	"fmt"
	"github.com/ethereum/go-ethereum/accounts/abi/bind"
	"github.com/ethereum/go-ethereum/common"
	"github.com/ethereum/go-ethereum/core"
	"github.com/ethereum/go-ethereum/crypto"
	"github.com/ethereum/go-ethereum/params"
	"github.com/synapsecns/sanguine/ethergo/backends/simulated"
	"github.com/synapsecns/sanguine/ethergo/backends/simulated/multibackend"
	"github.com/synapsecns/sanguine/services/explorer/contracts/user/dfk/dfkhero"
	"github.com/synapsecns/sanguine/services/explorer/contracts/user/dfk/dfkpet"
	"github.com/synapsecns/sanguine/services/explorer/contracts/user/dfk/dfktear"
	"github.com/synapsecns/sanguine/services/explorer/graphql/server/graph/model"
	"math/big"
	"sync"
)

// globMux is a global mutex to protect the global message parsing map
// to parse messages, we start up a simulated network and add the contracts to it
// to avoid slower start time, we do this in a go function at boot time.
// we lock the mutex here and then release it only acquiring read locks going forward since these are much cheaper.
var globMux sync.RWMutex

var decoders []Decoder

// Decoder decodes a message into a message type.
type Decoder func(ctx context.Context, message []byte) (model.MessageType, error)

func init() {
	go func() {
		err := deployParseNet()
		if err != nil {
			// TODO; is this such a good idea?
			panic(err)
		}
	}()
}

// Decode decodes message hex data.
func Decode(ctx context.Context, hexMessage string) model.MessageType {
	globMux.RLock()
	defer globMux.RUnlock()

	message := common.FromHex(hexMessage)

	if len(hexMessage) == 0 {
		return model.UnknownType{Known: false}
	}

	results := make([]model.MessageType, len(decoders))

	var wg sync.WaitGroup
	var sliceMux sync.Mutex
	for i, decoder := range decoders {
		wg.Add(1)
		i := i
		decoder := decoder // capture func literal
		go func() {
			defer wg.Done()
			messageType, err := decoder(ctx, message)
			if err != nil {
				return
			}
			if messageType != nil {
				sliceMux.Lock()
				results[i] = messageType
				sliceMux.Unlock()
			}
		}()
	}

	wg.Wait()

	// go in order of decoders from largest->smallest
	for _, result := range results {
		if result != nil {
			return result
		}
	}

	return model.UnknownType{Known: false}
}

func deployParseNet() error {
	globMux.Lock()
	defer globMux.Unlock()

	// 100 million ether
	balance := big.NewInt(0).Mul(big.NewInt(params.Ether), big.NewInt(100000000))

	privateKey, err := crypto.GenerateKey()
	if err != nil {
		return fmt.Errorf("failed to generate private key: %w", err)
	}

	chainID := params.AllEthashProtocolChanges.ChainID
	auth, err := bind.NewKeyedTransactorWithChainID(privateKey, chainID)
	if err != nil {
		return fmt.Errorf("failed to create authorized transactor: %w", err)
	}

	genesisAlloc := map[common.Address]core.GenesisAccount{
		auth.From: {
			Balance: balance,
		},
	}

	simulatedBackend := multibackend.NewSimulatedBackendWithConfig(genesisAlloc, simulated.BlockGasLimit, params.AllEthashProtocolChanges)

	_, _, heroBridge, err := dfkhero.DeployHeroBridgeUpgradeable(auth, simulatedBackend)
	if err != nil {
		return fmt.Errorf("could not deploy hero bridge: %w", err)
	}

	// Note: these should stay in order of largest to smallest
	decoders = append(decoders, func(ctx context.Context, message []byte) (model.MessageType, error) {
		messageFormat, err := heroBridge.DecodeMessage(&bind.CallOpts{Context: ctx}, message)
		if err != nil {
			return nil, fmt.Errorf("could not decode message: %w", err)
		}
		return model.HeroType{
			HeroID: messageFormat.DstHeroId.String(),
		}, nil
	})

	_, _, petBridge, err := dfkpet.DeployPetBridgeUpgradeable(auth, simulatedBackend)
	if err != nil {
		return fmt.Errorf("could not deploy hero bridge: %w", err)
	}

	decoders = append(decoders, func(ctx context.Context, message []byte) (model.MessageType, error) {
		messageFormat, err := petBridge.DecodeMessage(&bind.CallOpts{Context: ctx}, message)
		if err != nil {
			return nil, fmt.Errorf("could not decode message: %w", err)
		}
		return model.PetType{
			PetID: messageFormat.DstPet.Id.String(),
			Name:  messageFormat.DstPet.Name,
		}, nil
	})

	_, _, tearBridge, err := dfktear.DeployTearBridge(auth, simulatedBackend, common.Address{}, common.Address{})
	if err != nil {
		return fmt.Errorf("could not deploy hero bridge: %w", err)
	}

	decoders = append(decoders, func(ctx context.Context, message []byte) (model.MessageType, error) {
		messageFormat, err := tearBridge.DecodeMessage(&bind.CallOpts{Context: ctx}, message)
		if err != nil {
			return nil, fmt.Errorf("could not decode message: %w", err)
		}
		return model.TearType{
			Amount: messageFormat.DstTearAmount.String(),
		}, nil
	})

	simulatedBackend.Commit()

	return nil
}