package api

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"time"

	"github.com/ethereum/go-ethereum/common"
	"github.com/gin-gonic/gin"
	db2 "github.com/synapsecns/sanguine/services/cctp-relayer/db"
	"golang.org/x/sync/errgroup"
	"gorm.io/gorm"
)

// RelayerAPIServer exposes API endpoints that interact with CCTPRelayer.
type RelayerAPIServer struct {
	port             uint16
	host             string
	db               db2.CCTPRelayerDB
	relayRequestChan chan *RelayRequest
}

// NewRelayerAPIServer creates a new RelayerAPIServer.
func NewRelayerAPIServer(port uint16, host string, db db2.CCTPRelayerDB, relayRequestChan chan *RelayRequest) *RelayerAPIServer {
	return &RelayerAPIServer{
		port:             port,
		host:             host,
		db:               db,
		relayRequestChan: relayRequestChan,
	}
}

// Start starts the RelayerAPIServer.
func (r RelayerAPIServer) Start(ctx context.Context) error {
	engine := gin.Default()
	engine.GET("/tx", func(ctx *gin.Context) {
		r.GetTx(ctx)
	})
	server := &http.Server{
		Addr:              fmt.Sprintf(":%d", r.port),
		ReadHeaderTimeout: 5 * time.Second,
		Handler:           engine,
	}

	g, ctx := errgroup.WithContext(ctx)

	g.Go(func() error {
		err := server.ListenAndServe()
		if err != nil {
			return fmt.Errorf("stopped serving: %w", err)
		}
		return nil
	})

	g.Go(func() error {
		// shutdown server if parent context is canceled
		<-ctx.Done()
		shutdownCtx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
		defer cancel()
		err := server.Shutdown(shutdownCtx)
		if err != nil {
			return fmt.Errorf("error during server shutdown: %w", err)
		}
		return nil
	})

	err := g.Wait()
	if err != nil {
		return fmt.Errorf("error while serving: %w", err)
	}

	return nil
}

// RelayRequest is a request to relay a transaction.
type RelayRequest struct {
	Origin uint32
	TxHash common.Hash
}

// GetTx handles the /tx endpoint.
// If the transaction is found in the db, return information about the transaction.
// Otherwise, queue the corresponding Message for relay.
func (r RelayerAPIServer) GetTx(ctx *gin.Context) {
	// parse params
	origin, err := getOriginParam(ctx)
	if err != nil {
		encodeError(ctx, http.StatusBadRequest, err)
		return
	}
	hash, err := getHashParam(ctx)
	if err != nil {
		encodeError(ctx, http.StatusBadRequest, err)
		return
	}

	// fetch corresponding hash from db
	msg, err := r.db.GetMessageByOriginHash(ctx, common.HexToHash(hash))
	if err == nil {
		// return if found
		resp := RelayerResponse{
			Success: true,
			Result: MessageResult{
				OriginHash:      hash,
				DestinationHash: msg.DestTxHash,
				Origin:          msg.OriginChainID,
				Destination:     msg.DestChainID,
				RequestID:       msg.RequestID,
				State:           msg.State.String(),
			},
		}
		ctx.JSON(http.StatusOK, resp)
		return
	} else if errors.Is(err, gorm.ErrRecordNotFound) {
		// enqueue new pending message if not found
		r.relayRequestChan <- &RelayRequest{
			Origin: origin,
			TxHash: common.HexToHash(hash),
		}
		resp := RelayerResponse{
			Success: true,
			Result:  fmt.Sprintf("Successfully queued relay request from chain %d: %s", origin, hash),
		}
		ctx.JSON(http.StatusOK, resp)
		return
	}

	encodeError(ctx, http.StatusInternalServerError, err)
}

// MessageResult is the result of a successful /tx request.
type MessageResult struct {
	OriginHash      string `json:"origin_hash"`
	DestinationHash string `json:"destination_hash"`
	Origin          uint32 `json:"origin"`
	Destination     uint32 `json:"destination"`
	RequestID       string `json:"request_id"`
	State           string `json:"state"`
}

// RelayerResponse is a wrapper struct for a relayer API response.
type RelayerResponse struct {
	Success bool        `json:"success"`
	Result  interface{} `json:"result"`
}

type errorResult struct {
	Reason string `json:"reason"`
}

func encodeError(ctx *gin.Context, status int, err error) {
	resp := RelayerResponse{
		Success: false,
		Result: errorResult{
			Reason: err.Error(),
		},
	}
	ctx.JSON(status, resp)
}