package service

import (
	"bytes"
	"context"
	"net/http"
	"wallet-system/internal/biz"
	"wallet-system/internal/service/result"
	"wallet-system/internal/service/validation"

	v1 "wallet-system/api/walletSystem/v1"
)

// WalletService
// @Description:
type WalletService struct {
	v1.UnimplementedWalletServer

	uc *biz.WalletInfo
}

// NewWalletService
//
//	@Description:
//	@param uc
//	@return *WalletService
func NewWalletService(uc *biz.WalletInfo) *WalletService {
	return &WalletService{uc: uc}
}

// GenerateAddress
//
//	@Description:
//	@receiver s
//	@param ctx
//	@param in
//	@return *v1.WalletReply
//	@return error
func (s *WalletService) GenerateAddress(ctx context.Context, in *v1.GenerateAddressRequest) (*v1.WalletReply, error) {
	if err := validation.GenerateAddressValidation(in); err != nil {
		return result.WalletReplyErrorResult(false, []string{}, err.Error()), err
	}

	data, err := s.uc.GenerateAddress(ctx, in.Wallet, in.Number)
	if err != nil {
		return result.WalletReplyErrorResult(false, []string{}, err.Error()), err
	}

	return &v1.WalletReply{
		Code:    http.StatusOK,
		Data:    data,
		Message: validation.Success,
	}, nil
}

// SignatureTrc20Grpc
//
//	@Description:
//	@receiver s
//	@param ctx
//	@param in
//	@return *v1.SignatureTrc20Reply
//	@return error
func (s *WalletService) SignatureTrc20Grpc(ctx context.Context, in *v1.SignatureTrc20Request) (*v1.SignatureTrc20Reply, error) {
	if err := validation.SignatureTrc20GrpcValidation(in); err != nil {
		return result.SignatureTrc20GrpcResult(false, &v1.Data{}, err.Error()), err
	}

	check, data, err := s.uc.SignatureTrc20Grpc(ctx, &biz.Wallet{
		From:     in.From,
		To:       in.To,
		Amount:   in.Amount,
		Contract: in.Contract,
		TrcCheck: in.TrcCheck,
		TokenId:  in.TokenId,
		FeeLimit: in.FeeLimit,
	})
	if err != nil {
		return result.SignatureTrc20GrpcResult(false, &v1.Data{}, err.Error()), err
	}

	return &v1.SignatureTrc20Reply{
		Code: http.StatusOK,
		Data: &v1.Data{
			Result: check,
			TxId:   data,
		},
		Message: validation.Success,
	}, nil
}

// GetAllAddress
//
//	@Description:
//	@receiver s
//	@param ctx
//	@param in
//	@return *v1.WalletReply
//	@return error
func (s *WalletService) GetAllAddress(ctx context.Context, in *v1.WalletRequest) (*v1.WalletReply, error) {
	data, err := s.uc.GetAllAddress(ctx)
	if err != nil {
		return result.WalletReplyErrorResult(false, []string{}, err.Error()), err
	}

	return &v1.WalletReply{
		Code:    http.StatusOK,
		Data:    data,
		Message: validation.Success,
	}, nil
}

// GetAllAddressAndPrivateKey
//
//	@Description:
//	@receiver s
//	@param ctx
//	@param in
//	@return *v1.WalletKeyReply
//	@return error
func (s *WalletService) GetAllAddressAndPrivateKey(ctx context.Context, in *v1.WalletRequest) (*v1.WalletKeyReply, error) {
	data, err := s.uc.GetAllAddressAndPrivateKey(ctx)
	if err != nil {
		return result.WalletKeyReplyErrorResult(false, []*v1.Keys{}, err.Error()), err
	}

	var keys []*v1.Keys
	for key, value := range data {
		var b bytes.Buffer
		b.Write(value)
		bytesData := b.Bytes()

		vue := &v1.Keys{
			Key:   key,
			Value: bytesData,
		}
		keys = append(keys, vue)
	}

	return &v1.WalletKeyReply{
		Code:    http.StatusOK,
		Data:    keys,
		Message: validation.Success,
	}, nil
}

// GetPrivateKeyByAddress
//
//	@Description:
//	@receiver s
//	@param ctx
//	@param in
//	@return *v1.WalletPKeysReply
//	@return error
func (s *WalletService) GetPrivateKeyByAddress(ctx context.Context, in *v1.GetPrivateKeyByAddressRequest) (*v1.WalletPKeysReply, error) {
	if err := validation.GetPrivateKeyByAddressValidation(in); err != nil {
		return result.WalletPKeysReplyErrorResult(false, "", err.Error()), err
	}

	data, err := s.uc.GetPrivateKeyByAddress(ctx, in.Address)
	if err != nil {
		return result.WalletPKeysReplyErrorResult(false, "", err.Error()), err
	}

	return &v1.WalletPKeysReply{
		Code:    http.StatusOK,
		Data:    data,
		Message: validation.Success,
	}, nil
}

// DeleteAddress
//
//	@Description:
//	@receiver s
//	@param ctx
//	@param in
//	@return *v1.WalletReply
//	@return error
func (s *WalletService) DeleteAddress(ctx context.Context, in *v1.WalletRequest) (*v1.WalletReply, error) {
	if err := s.uc.DeleteAddress(ctx); err != nil {
		return result.WalletReplyErrorResult(false, []string{}, err.Error()), err
	}

	return &v1.WalletReply{
		Code:    http.StatusOK,
		Data:    []string{},
		Message: validation.Success,
	}, nil
}

// WalletApprove
//
//	@Description:
//	@receiver s
//	@param ctx
//	@param in
//	@return *v1.WalletApproveReply
//	@return error
func (s *WalletService) WalletApprove(ctx context.Context, in *v1.WalletApproveRequest) (*v1.WalletApproveReply, error) {
	if err := validation.WalletApproveValidation(in); err != nil {
		return result.WalletApproveResult(false, []byte{}, err.Error()), err
	}

	check, data, err := s.uc.WalletApprove(ctx, &biz.Wallet{
		From:     in.From,
		To:       in.To,
		Amount:   in.Amount,
		Contract: in.Contract,
		TrcCheck: in.TrcCheck,
		TokenId:  in.TokenId,
		FeeLimit: in.FeeLimit,
	})
	if err != nil || !check {
		return result.WalletApproveResult(false, []byte{}, err.Error()), err
	}

	return &v1.WalletApproveReply{
		Code:    http.StatusOK,
		Data:    data,
		Message: validation.Success,
	}, nil
}