package filecoin

import (
	"bytes"
	"encoding/json"
	"fmt"

	ftypes "github.com/Secured-Finance/dione/rpc/filecoin/types"
	"github.com/Secured-Finance/dione/rpc/types"
	"github.com/filecoin-project/go-address"

	"github.com/sirupsen/logrus"
	"github.com/valyala/fasthttp"
)

var filecoinURL = "https://api.node.glif.io/"

const (
	blsType       = 0x1
	secp256k1Type = 0x2
)

// client implements the `Client` interface.
type LotusClient struct {
	host       string
	httpClient *fasthttp.Client
}

// NewClient returns a new client.
func NewLotusClient() *LotusClient {
	return &LotusClient{
		host:       filecoinURL,
		httpClient: &fasthttp.Client{},
	}
}

func (c *LotusClient) GetBlock(cid string) ([]byte, error) {
	i := ftypes.NewCidParam(cid)
	return c.HandleRequest("Filecoin.ChainGetBlock", i)
}

func (c *LotusClient) GetTipSetByHeight(chainEpoch int64) ([]byte, error) {
	i := make([]interface{}, 0)
	i = append(i, chainEpoch, nil)
	return c.HandleRequest("Filecoin.ChainGetTipSetByHeight", i)
}

// func (c *LotusClient) GetTransaction(cid string) (string, error) {
// 	i := ftypes.NewCidParam(cid)
// 	resp, err := c.HandleRequest("Filecoin.ChainGetMessage", i)
// 	return string(resp), err
// }

func (c *LotusClient) GetNodeVersion() ([]byte, error) {
	return c.HandleRequest("Filecoin.Version", nil)
}

func (c *LotusClient) GetChainHead() ([]byte, error) {
	return c.HandleRequest("Filecoin.ChainHead", nil)
}

func (c *LotusClient) VerifyCid(cid string) ([]byte, error) {
	i := ftypes.NewCidParam(cid)
	return c.HandleRequest("Filecoin.ChainHasObj", i)
}

// Gets signed transaction from Filecoin and returns SignedTransaction struct in byte slice
func (c *LotusClient) GetTransaction(cid string) ([]byte, error) {
	i := ftypes.NewCidParam(cid)
	bodyBytes, err := c.HandleRequest("Filecoin.ChainReadObj", i)
	if err != nil {
		return nil, fmt.Errorf("Failed to get object information %v", err)
	}
	var response types.RPCResponseBody
	err = json.Unmarshal(bodyBytes, &response)
	if err != nil {
		return nil, fmt.Errorf("Failed to unmarshal response body %v", err)
	}

	var msg ftypes.SignedMessage
	if err := msg.UnmarshalCBOR(bytes.NewReader(response.Result)); err != nil {
		if err := msg.Message.UnmarshalCBOR(bytes.NewReader(response.Result)); err != nil {
			return nil, err
		}
	}

	switch msg.Message.From.Protocol() | msg.Message.To.Protocol() {
	case address.BLS:
		msg.Type = blsType
	case address.SECP256K1:
		msg.Type = secp256k1Type
	default:
		return nil, fmt.Errorf("Address has unsupported protocol %v", err)
	}

	b := new(bytes.Buffer)
	if err := msg.MarshalCBOR(b); err != nil {
		return nil, err
	}
	return b.Bytes(), nil
}

// HandleRequest implements the `Client` interface.
func (c *LotusClient) HandleRequest(method string, params []interface{}) ([]byte, error) {
	req := fasthttp.AcquireRequest()
	req.SetRequestURI(c.host)
	req.Header.SetMethod("POST")
	req.Header.SetContentType("application/json")
	requestBody := types.NewRPCRequestBody(method)
	requestBody.Params = append(requestBody.Params, params...)
	body, err := json.Marshal(requestBody)
	if err != nil {
		return nil, fmt.Errorf("Failed to marshal request body %v", err)
	}
	req.AppendBody(body)
	resp := fasthttp.AcquireResponse()
	if err = c.httpClient.Do(req, resp); err != nil {
		logrus.Warn("Failed to construct filecoin node rpc request", err)
		return nil, err
	}
	bodyBytes := resp.Body()
	logrus.Info(string(bodyBytes))
	return bodyBytes, nil
}