package max

import (
	"context"
	"encoding/json"
	"fmt"

	"github.com/c9s/bbgo/pkg/fixedpoint"
)

type RewardType string

const (
	RewardAirdrop    = RewardType("airdrop_reward")
	RewardCommission = RewardType("commission")
	RewardHolding    = RewardType("holding_reward")
	RewardMining     = RewardType("mining_reward")
	RewardTrading    = RewardType("trading_reward")
	RewardVipRebate  = RewardType("vip_rebate")
)

func ParseRewardType(s string) (RewardType, error) {
	switch s {
	case "airdrop_reward":
		return RewardAirdrop, nil
	case "commission":
		return RewardCommission, nil
	case "holding_reward":
		return RewardHolding, nil
	case "mining_reward":
		return RewardMining, nil
	case "trading_reward":
		return RewardTrading, nil
	case "vip_rebate":
		return RewardVipRebate, nil

	}

	return RewardType(""), fmt.Errorf("unknown reward type: %s", s)
}

func (t *RewardType) UnmarshalJSON(o []byte) error {
	var s string
	var err = json.Unmarshal(o, &s)
	if err != nil {
		return err
	}

	rt, err := ParseRewardType(s)
	if err != nil {
		return err
	}

	*t = rt
	return nil
}

type Reward struct {
	UUID     string           `json:"uuid"`
	Type     RewardType       `json:"type"`
	Currency string           `json:"currency"`
	Amount   fixedpoint.Value `json:"amount"`
	State    string           `json:"state"`
	Note     string           `json:"note"`

	// Unix timestamp in seconds
	CreatedAt Timestamp `json:"created_at"`
}

type RewardService struct {
	client *RestClient
}

func (s *RewardService) NewRewardsRequest() *RewardsRequest {
	return &RewardsRequest{client: s.client}
}

func (s *RewardService) NewRewardsByTypeRequest(pathType RewardType) *RewardsRequest {
	return &RewardsRequest{client: s.client, pathType: &pathType}
}

type RewardsRequest struct {
	client *RestClient

	pathType *RewardType

	currency *string

	// From Unix-timestamp
	from *int64

	// To Unix-timestamp
	to *int64
}

func (r *RewardsRequest) Currency(currency string) *RewardsRequest {
	r.currency = &currency
	return r
}

func (r *RewardsRequest) From(from int64) *RewardsRequest {
	r.from = &from
	return r
}

func (r *RewardsRequest) To(to int64) *RewardsRequest {
	r.to = &to
	return r
}

func (r *RewardsRequest) Do(ctx context.Context) (rewards []Reward, err error) {
	payload := map[string]interface{}{}

	if r.currency != nil {
		payload["currency"] = r.currency
	}

	if r.to != nil {
		payload["to"] = r.to
	}

	if r.from != nil {
		payload["from"] = r.from
	}

	refURL := "v2/rewards"

	if r.pathType != nil {
		refURL += "/" + string(*r.pathType)
	}

	req, err := r.client.newAuthenticatedRequest("GET", refURL, payload)
	if err != nil {
		return rewards, err
	}

	response, err := r.client.sendRequest(req)
	if err != nil {
		return rewards, err
	}

	if err := response.DecodeJSON(&rewards); err != nil {
		return rewards, err
	}

	return rewards, err
}