package binance

import (
	"context"
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"encoding/json"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"

	"hyapp/pkg/xerr"
	"hyapp/services/wallet-service/internal/config"
	"hyapp/services/wallet-service/internal/service/wallet/ports"
)

const (
	defaultDepositLookback = 90 * 24 * time.Hour
	depositHistoryLimit    = 1000
	defaultPayLookback     = 90 * 24 * time.Hour
	payOrderTimeRadius     = time.Hour
	payHistoryLimit        = 100
	binancePaySuccessCode  = "000000"
)

// Client 是 Binance 只读查单适配器；它只使用 signed read API，不保存、不生成任何链上私钥。
type Client struct {
	httpClient *http.Client
	apiBaseURL string
	recvWindow int64
	accounts   map[string]account
}

type account struct {
	apiKey       string
	apiSecretKey string
}

// New 从 wallet-service 配置创建 Binance client；具体 App 是否有账号在请求时按 appCode 决定。
func New(cfg config.BinanceConfig) *Client {
	timeout := cfg.HTTPTimeout
	if timeout <= 0 {
		timeout = 10 * time.Second
	}
	return &Client{
		httpClient: &http.Client{Timeout: timeout},
		apiBaseURL: strings.TrimRight(strings.TrimSpace(firstNonEmpty(cfg.APIBaseURL, "https://api.binance.com")), "/"),
		recvWindow: firstPositiveInt64(cfg.RecvWindow, 10000),
		accounts: map[string]account{
			"lalu":  newAccount(cfg.Lalu),
			"aslan": newAccount(cfg.Aslan),
			"yumi":  newAccount(cfg.Yumi),
		},
	}
}

func newAccount(cfg config.BinanceAccountConfig) account {
	return account{
		apiKey:       strings.TrimSpace(cfg.APIKey),
		apiSecretKey: strings.TrimSpace(cfg.APISecretKey),
	}
}

// FindUSDTTransfer 先查链上 Deposit History，再在未命中时查 Funding Account 的 Pay C2C History。
// 两个事实源的成功语义不同：链上入金必须校验网络、地址和状态；Pay C2C 必须校验正金额，证明是当前 API Key 账户收款而不是付款。
func (c *Client) FindUSDTTransfer(ctx context.Context, req ports.BinanceTransferLookupRequest) (ports.BinanceTransferRecord, error) {
	if c == nil || c.apiBaseURL == "" {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Unavailable, "binance client is not configured")
	}
	account, ok := c.accountForApp(req.AppCode)
	if !ok {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Unavailable, "binance account is not configured")
	}
	req.ExternalID = strings.TrimSpace(req.ExternalID)
	req.Coin = strings.ToUpper(strings.TrimSpace(req.Coin))
	req.Network = strings.ToUpper(strings.TrimSpace(req.Network))
	req.ToAddress = strings.TrimSpace(req.ToAddress)
	if req.ExternalID == "" || req.Coin == "" || req.Network == "" || req.AmountMinor <= 0 {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.InvalidArgument, "binance transfer verification request is incomplete")
	}
	serverTimeMS, err := c.serverTime(ctx)
	if err != nil {
		return ports.BinanceTransferRecord{}, err
	}
	// Binance 的 deposit history 查询窗口有限；后台凭证校验只做近期有界查询，避免一次手工校验变成无界扫描。
	records, err := c.depositHistory(ctx, account, req.Coin, serverTimeMS-int64(defaultDepositLookback/time.Millisecond), serverTimeMS)
	if err != nil {
		return ports.BinanceTransferRecord{}, err
	}
	matched, err := matchDepositRecord(req, records)
	if err == nil {
		return matched, nil
	}
	if !xerr.IsCode(err, xerr.NotFound) {
		// 同一编号已经命中链上事实但字段冲突时禁止切换事实源，避免用 Pay 记录绕过地址、网络或状态校验。
		return ports.BinanceTransferRecord{}, err
	}
	startTimeMS, endTimeMS := payHistoryRange(req.OrderTimeMS, serverTimeMS)
	payRecords, err := c.payHistory(ctx, account, startTimeMS, endTimeMS, serverTimeMS)
	if err != nil {
		return ports.BinanceTransferRecord{}, err
	}
	return matchPayRecord(req, payRecords)
}

func (c *Client) accountForApp(appCode string) (account, bool) {
	value, ok := c.accounts[strings.ToLower(strings.TrimSpace(appCode))]
	if !ok || strings.TrimSpace(value.apiKey) == "" || strings.TrimSpace(value.apiSecretKey) == "" {
		return account{}, false
	}
	return value, true
}

func (c *Client) serverTime(ctx context.Context) (int64, error) {
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, c.apiBaseURL+"/api/v3/time", nil)
	if err != nil {
		return 0, err
	}
	body, err := c.do(req)
	if err != nil {
		return 0, err
	}
	var parsed struct {
		ServerTime int64 `json:"serverTime"`
	}
	if err := json.Unmarshal(body, &parsed); err != nil {
		return 0, err
	}
	if parsed.ServerTime <= 0 {
		return 0, xerr.New(xerr.Unavailable, "binance server time is invalid")
	}
	return parsed.ServerTime, nil
}

func (c *Client) depositHistory(ctx context.Context, account account, coin string, startTimeMS int64, endTimeMS int64) ([]depositRecord, error) {
	query := url.Values{}
	query.Set("coin", strings.ToUpper(strings.TrimSpace(coin)))
	query.Set("startTime", strconv.FormatInt(startTimeMS, 10))
	query.Set("endTime", strconv.FormatInt(endTimeMS, 10))
	query.Set("limit", strconv.Itoa(depositHistoryLimit))
	body, err := c.signedGET(ctx, account, "/sapi/v1/capital/deposit/hisrec", query, endTimeMS)
	if err != nil {
		return nil, err
	}
	var raws []json.RawMessage
	if err := json.Unmarshal(body, &raws); err != nil {
		return nil, err
	}
	records := make([]depositRecord, 0, len(raws))
	for _, raw := range raws {
		var wire depositRecordWire
		if err := json.Unmarshal(raw, &wire); err != nil {
			return nil, err
		}
		record := wire.toRecord()
		record.RawJSON = string(raw)
		records = append(records, record)
	}
	return records, nil
}

// payHistory 查询 Binance Pay 用户账单。接口单次最多返回 100 条，调用方提供订单时间时使用窄窗口降低高频账户漏单概率。
func (c *Client) payHistory(ctx context.Context, account account, startTimeMS int64, endTimeMS int64, serverTimeMS int64) ([]payRecord, error) {
	query := url.Values{}
	query.Set("startTime", strconv.FormatInt(startTimeMS, 10))
	query.Set("endTime", strconv.FormatInt(endTimeMS, 10))
	query.Set("limit", strconv.Itoa(payHistoryLimit))
	// 查询区间可以是历史日期，但 signed API 的 timestamp 必须始终使用当前 Binance server time，否则旧订单会被 -1021 拒绝。
	body, err := c.signedGET(ctx, account, "/sapi/v1/pay/transactions", query, serverTimeMS)
	if err != nil {
		return nil, err
	}
	var response payHistoryResponse
	if err := json.Unmarshal(body, &response); err != nil {
		return nil, err
	}
	if strings.TrimSpace(response.Code) != binancePaySuccessCode || !response.Success {
		return nil, xerr.New(xerr.Unavailable, "binance pay history returned non-success")
	}
	records := make([]payRecord, 0, len(response.Data))
	for _, raw := range response.Data {
		var wire payRecordWire
		if err := json.Unmarshal(raw, &wire); err != nil {
			return nil, err
		}
		record := wire.toRecord()
		// Pay 回包含付款人与收款人的账户资料；持久审计只保留完成资金校验所需字段，避免把无关 PII 写入充值凭证。
		record.RawJSON = safePayRecordJSON(record)
		records = append(records, record)
	}
	return records, nil
}

func payHistoryRange(orderTimeMS int64, serverTimeMS int64) (int64, int64) {
	lookbackMS := int64(defaultPayLookback / time.Millisecond)
	if orderTimeMS <= 0 {
		return maxInt64(0, serverTimeMS-lookbackMS), serverTimeMS
	}
	radiusMS := int64(payOrderTimeRadius / time.Millisecond)
	startTimeMS := maxInt64(0, orderTimeMS-radiusMS)
	endTimeMS := minInt64(serverTimeMS, orderTimeMS+radiusMS)
	if endTimeMS <= startTimeMS {
		// 未来订单时间不应发生；这里返回最小合法区间，让 Binance 给出空结果而不是发出反向时间范围。
		endTimeMS = startTimeMS + 1
	}
	return startTimeMS, endTimeMS
}

func (c *Client) signedGET(ctx context.Context, account account, path string, values url.Values, timestampMS int64) ([]byte, error) {
	values.Set("recvWindow", strconv.FormatInt(c.recvWindow, 10))
	values.Set("timestamp", strconv.FormatInt(timestampMS, 10))
	queryString := values.Encode()
	signature := signQueryString(queryString, account.apiSecretKey)
	endpoint := c.apiBaseURL + path + "?" + queryString + "&signature=" + signature
	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint, nil)
	if err != nil {
		return nil, err
	}
	req.Header.Set("X-MBX-APIKEY", account.apiKey)
	return c.do(req)
}

func (c *Client) do(req *http.Request) ([]byte, error) {
	resp, err := c.httpClient.Do(req)
	if err != nil {
		return nil, xerr.New(xerr.Unavailable, "binance request failed")
	}
	defer resp.Body.Close()
	body, err := io.ReadAll(io.LimitReader(resp.Body, 2<<20))
	if err != nil {
		return nil, err
	}
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return nil, xerr.New(xerr.Unavailable, "binance returned non-success")
	}
	return body, nil
}

func matchDepositRecord(req ports.BinanceTransferLookupRequest, records []depositRecord) (ports.BinanceTransferRecord, error) {
	var candidate *depositRecord
	for index := range records {
		if depositTxIDMatches(records[index].TxID, req.ExternalID) {
			candidate = &records[index]
			break
		}
	}
	if candidate == nil {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.NotFound, "binance deposit not found")
	}
	if !strings.EqualFold(candidate.Coin, req.Coin) {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance deposit coin mismatch")
	}
	if !strings.EqualFold(candidate.Network, req.Network) {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance deposit network mismatch")
	}
	if candidate.Status != 1 {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance deposit status is not successful")
	}
	// Deposit History 属于具体链上入账，必须有预先配置的收款地址；允许空地址仅服务于随后独立校验的 Pay C2C 事实源。
	if strings.TrimSpace(req.ToAddress) == "" || !strings.EqualFold(strings.TrimSpace(candidate.Address), strings.TrimSpace(req.ToAddress)) {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance deposit address mismatch")
	}
	amountMinor, err := parseUSDTAmountMinor(candidate.Amount)
	if err != nil {
		return ports.BinanceTransferRecord{}, err
	}
	if amountMinor != req.AmountMinor {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance deposit amount mismatch")
	}
	return ports.BinanceTransferRecord{
		Source:         "deposit_history",
		ID:             candidate.ID,
		TxID:           candidate.TxID,
		Coin:           candidate.Coin,
		Network:        candidate.Network,
		Status:         candidate.Status,
		Address:        candidate.Address,
		Amount:         candidate.Amount,
		AmountMinor:    amountMinor,
		TransferType:   candidate.TransferType,
		InsertTimeMS:   candidate.InsertTimeMS,
		CompleteTimeMS: candidate.CompleteTimeMS,
		ConfirmTimes:   candidate.ConfirmTimes,
		UnlockConfirm:  candidate.UnlockConfirm,
		WalletType:     candidate.WalletType,
		RawJSON:        strings.TrimSpace(candidate.RawJSON),
	}, nil
}

func matchPayRecord(req ports.BinanceTransferLookupRequest, records []payRecord) (ports.BinanceTransferRecord, error) {
	var candidate *payRecord
	for index := range records {
		if payExternalIDMatches(records[index], req.ExternalID) {
			candidate = &records[index]
			break
		}
	}
	if candidate == nil {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.NotFound, "binance pay transfer not found")
	}
	if !strings.EqualFold(candidate.OrderType, "C2C") {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance pay order type is not c2c")
	}
	if !strings.EqualFold(candidate.Currency, req.Coin) {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance pay currency mismatch")
	}
	// Binance Pay 官方语义中正数是当前 API Key 账户收入、负数是支出；只允许正数，防止付款截图被当成平台收款。
	if strings.HasPrefix(strings.TrimSpace(candidate.Amount), "-") {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance pay transfer is not income")
	}
	amountMinor, err := parseUSDTAmountMinor(candidate.Amount)
	if err != nil {
		return ports.BinanceTransferRecord{}, err
	}
	if amountMinor <= 0 {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance pay transfer is not income")
	}
	if amountMinor != req.AmountMinor {
		return ports.BinanceTransferRecord{}, xerr.New(xerr.Conflict, "binance pay amount mismatch")
	}
	return ports.BinanceTransferRecord{
		Source:         "pay_history",
		ID:             candidate.OrderID,
		TxID:           firstNonEmpty(candidate.TransactionID, candidate.OrderID),
		Coin:           candidate.Currency,
		Status:         1,
		Amount:         candidate.Amount,
		AmountMinor:    amountMinor,
		InsertTimeMS:   candidate.TransactionTimeMS,
		CompleteTimeMS: candidate.TransactionTimeMS,
		WalletType:     candidate.WalletType,
		RawJSON:        strings.TrimSpace(candidate.RawJSON),
	}, nil
}

func payExternalIDMatches(record payRecord, externalID string) bool {
	externalID = strings.TrimSpace(externalID)
	if externalID == "" {
		return false
	}
	return strings.EqualFold(strings.TrimSpace(record.OrderID), externalID) ||
		strings.EqualFold(strings.TrimSpace(record.TransactionID), externalID)
}

func depositTxIDMatches(txID string, externalID string) bool {
	normalizedExternalID := normalizeOffchainExternalID(externalID)
	if normalizedExternalID == "" {
		return false
	}
	normalizedTxID := strings.ToLower(strings.TrimSpace(txID))
	return strings.Contains(normalizedTxID, normalizedExternalID) || normalizeOffchainExternalID(txID) == normalizedExternalID
}

func normalizeOffchainExternalID(value string) string {
	value = strings.ToLower(strings.TrimSpace(value))
	value = strings.TrimPrefix(value, "off-chain transfer")
	value = strings.TrimSpace(strings.Trim(value, ":#"))
	return value
}

func parseUSDTAmountMinor(value string) (int64, error) {
	value = strings.TrimSpace(value)
	if value == "" || strings.HasPrefix(value, "-") {
		return 0, xerr.New(xerr.InvalidArgument, "binance deposit amount is invalid")
	}
	parts := strings.Split(value, ".")
	if len(parts) > 2 {
		return 0, xerr.New(xerr.InvalidArgument, "binance deposit amount is invalid")
	}
	whole, err := strconv.ParseInt(firstNonEmpty(parts[0], "0"), 10, 64)
	if err != nil {
		return 0, xerr.New(xerr.InvalidArgument, "binance deposit amount is invalid")
	}
	frac := ""
	if len(parts) == 2 {
		frac = parts[1]
	}
	if len(frac) > 2 && strings.Trim(frac[2:], "0") != "" {
		return 0, xerr.New(xerr.Conflict, "binance deposit amount has sub-cent precision")
	}
	if len(frac) > 2 {
		frac = frac[:2]
	}
	for len(frac) < 2 {
		frac += "0"
	}
	minorFrac, err := strconv.ParseInt(firstNonEmpty(frac, "0"), 10, 64)
	if err != nil {
		return 0, xerr.New(xerr.InvalidArgument, "binance deposit amount is invalid")
	}
	return whole*100 + minorFrac, nil
}

func signQueryString(queryString string, secret string) string {
	mac := hmac.New(sha256.New, []byte(secret))
	_, _ = mac.Write([]byte(queryString))
	return hex.EncodeToString(mac.Sum(nil))
}

func firstNonEmpty(values ...string) string {
	for _, value := range values {
		if strings.TrimSpace(value) != "" {
			return strings.TrimSpace(value)
		}
	}
	return ""
}

func firstPositiveInt64(values ...int64) int64 {
	for _, value := range values {
		if value > 0 {
			return value
		}
	}
	return 0
}

type depositRecord struct {
	ID             string
	Amount         string
	Coin           string
	Network        string
	Status         int64
	Address        string
	TxID           string
	TransferType   int64
	InsertTimeMS   int64
	CompleteTimeMS int64
	ConfirmTimes   string
	UnlockConfirm  int64
	WalletType     int64
	RawJSON        string
}

type depositRecordWire struct {
	ID             json.RawMessage `json:"id"`
	Amount         string          `json:"amount"`
	Coin           string          `json:"coin"`
	Network        string          `json:"network"`
	Status         int64           `json:"status"`
	Address        string          `json:"address"`
	TxID           string          `json:"txId"`
	TransferType   int64           `json:"transferType"`
	InsertTimeMS   int64           `json:"insertTime"`
	CompleteTimeMS int64           `json:"completeTime"`
	ConfirmTimes   string          `json:"confirmTimes"`
	UnlockConfirm  int64           `json:"unlockConfirm"`
	WalletType     int64           `json:"walletType"`
}

type payHistoryResponse struct {
	Code    string            `json:"code"`
	Message string            `json:"message"`
	Success bool              `json:"success"`
	Data    []json.RawMessage `json:"data"`
}

type payRecord struct {
	OrderType         string
	OrderID           string
	TransactionID     string
	TransactionTimeMS int64
	Amount            string
	Currency          string
	WalletType        int64
	RawJSON           string
}

type payRecordWire struct {
	OrderType         string          `json:"orderType"`
	OrderID           json.RawMessage `json:"orderId"`
	TransactionID     string          `json:"transactionId"`
	TransactionTimeMS int64           `json:"transactionTime"`
	Amount            string          `json:"amount"`
	Currency          string          `json:"currency"`
	WalletType        int64           `json:"walletType"`
}

func (wire payRecordWire) toRecord() payRecord {
	return payRecord{
		OrderType:         strings.ToUpper(strings.TrimSpace(wire.OrderType)),
		OrderID:           rawScalarString(wire.OrderID),
		TransactionID:     strings.TrimSpace(wire.TransactionID),
		TransactionTimeMS: wire.TransactionTimeMS,
		Amount:            strings.TrimSpace(wire.Amount),
		Currency:          strings.ToUpper(strings.TrimSpace(wire.Currency)),
		WalletType:        wire.WalletType,
	}
}

func safePayRecordJSON(record payRecord) string {
	payload := struct {
		OrderType         string `json:"orderType"`
		OrderID           string `json:"orderId,omitempty"`
		TransactionID     string `json:"transactionId"`
		TransactionTimeMS int64  `json:"transactionTime"`
		Amount            string `json:"amount"`
		Currency          string `json:"currency"`
		WalletType        int64  `json:"walletType"`
	}{
		OrderType:         record.OrderType,
		OrderID:           record.OrderID,
		TransactionID:     record.TransactionID,
		TransactionTimeMS: record.TransactionTimeMS,
		Amount:            record.Amount,
		Currency:          record.Currency,
		WalletType:        record.WalletType,
	}
	body, err := json.Marshal(payload)
	if err != nil {
		return ""
	}
	return string(body)
}

func (wire depositRecordWire) toRecord() depositRecord {
	return depositRecord{
		ID:             rawScalarString(wire.ID),
		Amount:         strings.TrimSpace(wire.Amount),
		Coin:           strings.ToUpper(strings.TrimSpace(wire.Coin)),
		Network:        strings.ToUpper(strings.TrimSpace(wire.Network)),
		Status:         wire.Status,
		Address:        strings.TrimSpace(wire.Address),
		TxID:           strings.TrimSpace(wire.TxID),
		TransferType:   wire.TransferType,
		InsertTimeMS:   wire.InsertTimeMS,
		CompleteTimeMS: wire.CompleteTimeMS,
		ConfirmTimes:   strings.TrimSpace(wire.ConfirmTimes),
		UnlockConfirm:  wire.UnlockConfirm,
		WalletType:     wire.WalletType,
	}
}

func rawScalarString(raw json.RawMessage) string {
	if len(raw) == 0 || string(raw) == "null" {
		return ""
	}
	var text string
	if err := json.Unmarshal(raw, &text); err == nil {
		return strings.TrimSpace(text)
	}
	return strings.TrimSpace(string(raw))
}

func minInt64(left int64, right int64) int64 {
	if left < right {
		return left
	}
	return right
}

func maxInt64(left int64, right int64) int64 {
	if left > right {
		return left
	}
	return right
}