package upstreamimpl

import (
	"context"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"strconv"
	"strings"
	"time"
)

const xuzhouMobileTokenPath = "/admin/api/get/token"

// XuzhouMobileTokenConfig contains the public provider endpoint and the
// carrier type configured by the template. AppID is the per-channel
// credential and is deliberately not read from the template.
type XuzhouMobileTokenConfig struct {
	BaseURL     string
	Path        string
	AppID       string
	CarrierType int
	TTL         time.Duration
	Timeout     time.Duration
}

// XuzhouMobileTokenProvider fetches the shared OneLink token issued by the
// Xuzhou Mobile provider.
type XuzhouMobileTokenProvider struct {
	baseURL     string
	path        string
	appID       string
	carrierType int
	ttl         time.Duration
	client      *http.Client
}

type xuzhouMobileTokenResponse struct {
	Success   bool            `json:"success"`
	ErrorCode json.RawMessage `json:"errorCode"`
	Body      struct {
		Token string `json:"token"`
	} `json:"body"`
}

func parseXuzhouErrorCode(raw json.RawMessage) (int, error) {
	var code int
	if err := json.Unmarshal(raw, &code); err == nil {
		return code, nil
	}
	var value string
	if err := json.Unmarshal(raw, &value); err != nil {
		return 0, err
	}
	return strconv.Atoi(strings.TrimSpace(value))
}

func NewXuzhouMobileTokenProvider(config XuzhouMobileTokenConfig) *XuzhouMobileTokenProvider {
	timeout := config.Timeout
	if timeout <= 0 {
		timeout = defaultUpstreamHTTPTimeout
	}
	return &XuzhouMobileTokenProvider{
		baseURL:     strings.TrimRight(strings.TrimSpace(config.BaseURL), "/"),
		path:        normalizeProviderPath(config.Path, xuzhouMobileTokenPath),
		appID:       strings.TrimSpace(config.AppID),
		carrierType: config.CarrierType,
		ttl:         config.TTL,
		client:      &http.Client{Timeout: timeout},
	}
}

func (p *XuzhouMobileTokenProvider) Fetch(ctx context.Context) (OneLinkToken, error) {
	if p == nil || p.client == nil {
		return OneLinkToken{}, fmt.Errorf("xuzhou mobile token provider is not initialized")
	}
	if p.baseURL == "" {
		return OneLinkToken{}, fmt.Errorf("xuzhou mobile token base URL is required")
	}
	if p.appID == "" {
		return OneLinkToken{}, fmt.Errorf("xuzhou mobile appId is required")
	}

	endpoint, err := url.Parse(joinProviderURL(p.baseURL, p.path))
	if err != nil {
		return OneLinkToken{}, fmt.Errorf("parse Xuzhou Mobile token URL: %w", err)
	}
	query := endpoint.Query()
	query.Set("appid", p.appID)
	query.Set("carrierType", strconv.Itoa(p.carrierType))
	endpoint.RawQuery = query.Encode()

	req, err := http.NewRequestWithContext(ctx, http.MethodGet, endpoint.String(), nil)
	if err != nil {
		return OneLinkToken{}, fmt.Errorf("create Xuzhou Mobile token request: %w", err)
	}
	req.Header.Set("Accept", "application/json")
	resp, err := p.client.Do(req)
	if err != nil {
		return OneLinkToken{}, fmt.Errorf("request Xuzhou Mobile token: %w", err)
	}
	defer resp.Body.Close()
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		return OneLinkToken{}, fmt.Errorf("read Xuzhou Mobile token response: %w", err)
	}
	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		return OneLinkToken{}, fmt.Errorf("Xuzhou Mobile token HTTP status %d: %s", resp.StatusCode, strings.TrimSpace(string(body)))
	}

	var output xuzhouMobileTokenResponse
	if err := json.Unmarshal(body, &output); err != nil {
		return OneLinkToken{}, fmt.Errorf("decode Xuzhou Mobile token response: %w", err)
	}
	errorCode, err := parseXuzhouErrorCode(output.ErrorCode)
	if err != nil {
		return OneLinkToken{}, fmt.Errorf("decode Xuzhou Mobile errorCode: %w", err)
	}
	if !output.Success || errorCode != 0 {
		return OneLinkToken{}, fmt.Errorf("Xuzhou Mobile token failed: success=%t, errorCode=%d", output.Success, errorCode)
	}
	value := strings.TrimSpace(output.Body.Token)
	if value == "" {
		return OneLinkToken{}, fmt.Errorf("Xuzhou Mobile shared token is empty")
	}
	now := time.Now()
	expiresAt := time.Time{}
	if p.ttl > 0 {
		expiresAt = now.Add(p.ttl)
	}
	return OneLinkToken{Value: value, CreatedAt: now, ExpiresAt: expiresAt}, nil
}

func (p *XuzhouMobileTokenProvider) FetchToken(ctx context.Context, _ string) (OneLinkToken, error) {
	return p.Fetch(ctx)
}

func normalizeProviderPath(path, fallback string) string {
	path = strings.TrimSpace(path)
	if path == "" {
		path = fallback
	}
	if !strings.HasPrefix(path, "/") {
		path = "/" + path
	}
	return path
}

func joinProviderURL(baseURL, path string) string {
	return strings.TrimRight(strings.TrimSpace(baseURL), "/") + normalizeProviderPath(path, "/")
}