package blockchain

import (
	"fmt"
	"gitlink.org.cn/cloudream/common/utils/http2"
	"gitlink.org.cn/cloudream/common/utils/serder"
	"net/url"
	"strings"
	"time"
)

type InvokeReq struct {
	ContractAddress string   `json:"contractAddress"`
	FunctionName    string   `json:"functionName"`
	MemberName      string   `json:"memberName"`
	Type            string   `json:"type"`
	Args            []string `json:"args"`
	Amount          int64    `json:"amount"`
}

func (c *Client) BlockChainInvoke(req InvokeReq, token string) error {
	targetUrl, err := url.JoinPath(c.baseURL, "/jcc-bcos/contract/invoke")
	if err != nil {
		return err
	}

	header := make(map[string]string)
	header["Content-Type"] = http2.ContentTypeJSON
	header["Authorization"] = token

	resp, err := http2.PostJSON(targetUrl, http2.RequestParam{
		Body:   req,
		Header: header,
	})
	if err != nil {
		println(err)
		return err
	}

	var codeResp response[string]
	if err := serder.JSONToObjectStream(resp.Body, &codeResp); err != nil {
		println(err)
		return fmt.Errorf("parsing response: %w", err)
	}

	if codeResp.Code != ResponseCodeOK {
		println(codeResp.ToError().Message)
		return codeResp.ToError()
	}

	return nil
}

type UnPledgePointsReq struct {
	PrivateKey   string    `form:"privateKey"`
	BusinessCode string    `form:"businessCode"`
	EndTime      time.Time `form:"endTime"`
}

func (c *Client) UnPledgePoints(req UnPledgePointsReq, token string) error {
	targetUrl, err := url.JoinPath(c.baseURL, "/jcc-bcos/points/unPledgePoints")
	if err != nil {
		return err
	}

	header := make(map[string]string)
	header["Content-Type"] = http2.ContentTypeJSON
	header["Authorization"] = token

	resp, err := http2.PutJSON(targetUrl, http2.RequestParam{
		Query:  req,
		Header: header,
	})
	if err != nil {
		println(err)
		return err
	}

	contType := resp.Header.Get("Content-Type")
	if strings.Contains(contType, http2.ContentTypeJSON) {
		var codeResp response[string]
		if err := serder.JSONToObjectStream(resp.Body, &codeResp); err != nil {
			return fmt.Errorf("parsing response: %w", err)
		}

		if codeResp.Code == 200 {
			return nil
		}

		return codeResp.ToError()
	}

	return nil
}

type TokenReq struct {
	Username string `json:"username"`
	Password string `json:"password"`
}

type TokenResp struct {
	RoleID string `json:"roleId"`
	Token  string `json:"token"`
}

func (c *Client) getToken() (string, error) {
	targetUrl, err := url.JoinPath(c.loginUrl, "/jcc-admin/admin/login")
	if err != nil {
		return "", err
	}

	req := TokenReq{
		Username: c.userName,
		Password: c.password,
	}

	header := make(map[string]string)
	header["User-Agent"] = "Apifox/1.0.0 (https://apifox.com)"
	header["Content-Type"] = "application/json"
	header["Accept"] = "*/*"
	header["Host"] = "dev.jointcloud.net"
	header["Connection"] = "keep-alive"

	resp, err := http2.PostJSON(targetUrl, http2.RequestParam{
		Body:   req,
		Header: header,
	})
	if err != nil {
		return "", err
	}
	contType := resp.Header.Get("Content-Type")
	if strings.Contains(contType, http2.ContentTypeJSON) {

		var codeResp response[TokenResp]
		if err := serder.JSONToObjectStream(resp.Body, &codeResp); err != nil {
			return "", fmt.Errorf("parsing response: %w", err)
		}

		if codeResp.Code == ResponseCodeOK {
			return "Bearer " + codeResp.Data.Token, nil
		}

		return "", codeResp.ToError()
	}
	return "", fmt.Errorf("error: %w", err)
}