package proxy

import (
	"context"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/goccy/go-json"
	"github.com/puzpuzpuz/xsync"
	"github.com/synapsecns/sanguine/ethergo/client"
	"github.com/synapsecns/sanguine/ethergo/parser/rpc"
	"github.com/synapsecns/sanguine/services/omnirpc/chainmanager"
	omniHTTP "github.com/synapsecns/sanguine/services/omnirpc/http"
	"go.opentelemetry.io/otel/trace"
)

// IsConfirmable exports isConfirmable for testing.
func IsConfirmable(body []byte) (bool, error) {
	parsedPayload, err := rpc.ParseRPCPayload(body)
	if err != nil {
		return false, fmt.Errorf("could not parse payload: %w", err)
	}

	//nolint: wrapcheck
	return areConfirmable(parsedPayload)
}

// SetClient allows overriding the client on the rpc proxy.
func (r *RPCProxy) SetClient(client omniHTTP.Client) {
	r.client = client
}

// RawResponse exports rawResponse for testing.
type RawResponse interface {
	Body() []byte
	URL() string
	Hash() string
}

// ForwardRequest exports forward request for testing.
func (f *Forwarder) ForwardRequest(ctx context.Context, endpoint string) (RawResponse, error) {
	//nolint: wrapcheck
	return f.forwardRequest(ctx, endpoint)
}

func (r rawResponse) Body() []byte {
	return r.body
}

func (r rawResponse) URL() string {
	return r.url
}

func (f *Forwarder) R() *RPCProxy {
	return f.r
}

func (f *Forwarder) SetR(r *RPCProxy) {
	f.r = r
}

func (f *Forwarder) C() *gin.Context {
	return f.c
}

func (f *Forwarder) SetC(c *gin.Context) {
	f.c = c
}

func (f *Forwarder) Chain() chainmanager.Chain {
	return f.chain
}

func (f *Forwarder) SetChain(chain chainmanager.Chain) {
	f.chain = chain
}

func (f *Forwarder) Body() []byte {
	return f.body
}

func (f *Forwarder) SetBody(body []byte) {
	f.body = body
}

func (f *Forwarder) SetSpan(span trace.Span) {
	f.span = span
}

func (f *Forwarder) RequiredConfirmations() uint16 {
	return f.requiredConfirmations
}

func (f *Forwarder) SetRequiredConfirmations(requiredConfirmations uint16) {
	f.requiredConfirmations = requiredConfirmations
}

func (f *Forwarder) RequestID() []byte {
	return f.requestID
}

func (f *Forwarder) SetRequestID(requestID []byte) {
	f.requestID = requestID
}

func (f *Forwarder) Client() omniHTTP.Client {
	return f.client
}

func (f *Forwarder) SetClient(client omniHTTP.Client) {
	f.client = client
}

func (f *Forwarder) ResMap() *xsync.MapOf[string, []rawResponse] {
	return f.resMap
}

func (f *Forwarder) SetResMap(resMap *xsync.MapOf[string, []rawResponse]) {
	f.resMap = resMap
}

func (f *Forwarder) RPCRequest() []rpc.Request {
	return f.rpcRequest
}

func (f *Forwarder) SetRPCRequest(rpcRequest []rpc.Request) {
	f.rpcRequest = rpcRequest
}

func (r rawResponse) Hash() string {
	return r.hash
}

var _ RawResponse = rawResponse{}

// SetBlankResMap sets a forwarder to a new res map for testing.
func (f *Forwarder) SetBlankResMap() {
	f.SetResMap(xsync.NewMapOf[[]rawResponse]())
}

func StandardizeResponse(ctx context.Context, req []rpc.Request, body []byte) ([]byte, error) {
	var rpcMessage JSONRPCMessage
	err := json.Unmarshal(body, &rpcMessage)
	if err != nil {
		//nolint: wrapcheck
		return nil, err
	}
	var standardizedResponses []byte
	for i := range req {
		standardizedResponse, err := standardizeResponse(ctx, &req[i], rpcMessage)
		if err != nil {
			return nil, fmt.Errorf("could not standardize response: %w", err)
		}
		standardizedResponses = append(standardizedResponses, standardizedResponse...)
	}
	return standardizedResponses, nil
}

// StandardizeResponseFalseParams exports standardizeResponseFalseParams for testing.
// this is only used when params[1] is false when calling eth_getBlockByNumber or eth_getBlockByHash.
func StandardizeResponseFalseParams(ctx context.Context, req []rpc.Request, body []byte) ([]byte, error) {
	var rpcMessage JSONRPCMessage
	err := json.Unmarshal(body, &rpcMessage)
	if err != nil {
		//nolint: wrapcheck
		return nil, err
	}
	params := []json.RawMessage{rpcMessage.Params}

	// Handle BlockByHash, BlockByNumber, and HeaderByNumber events.
	if req[0].Method == string(client.BlockByHashMethod) || req[0].Method == string(client.BlockByNumberMethod) {
		blockNumber := "0x1"
		flag := true
		jsonBlockNumber, err := json.Marshal(&blockNumber)
		if err != nil {
			//nolint: wrapcheck
			return nil, err
		}
		jsonFlag, err := json.Marshal(&flag)
		if err != nil {
			//nolint: wrapcheck
			return nil, err
		}
		jsonRawParams := []json.RawMessage{jsonBlockNumber, jsonFlag}
		params = jsonRawParams
	}
	var standardizedResponses []byte
	for i := range req {
		rpcRequest := rpc.Request{
			ID:     rpcMessage.ID,
			Method: req[i].Method,
			Params: params,
		}
		standardizedResponse, err := standardizeResponse(ctx, &rpcRequest, rpcMessage)
		if err != nil {
			return nil, fmt.Errorf("could not standardize response: %w", err)
		}
		standardizedResponses = append(standardizedResponses, standardizedResponse...)
	}

	return standardizedResponses, nil
}

// CheckAndSetConfirmability exports checkAndSetConfirmability for testing.
func (f *Forwarder) CheckAndSetConfirmability() (ok bool) {
	return f.checkAndSetConfirmability()
}