package weixin_ilink

import (
	"context"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"strconv"
	"time"
)

// loginPollInterval is the default how often Connect polls the QR confirmation
// status. It is the documented ~1s cadence; the Config.LoginInterval field
// overrides it (used by tests to keep the flow short).
const loginPollInterval = 1 * time.Second

// qrcodeResp is the get_bot_qrcode response.
type qrcodeResp struct {
	Qrcode           string `json:"qrcode"`
	QrcodeImgContent string `json:"qrcode_img_content"`
}

// qrcodeStatusResp is the get_qrcode_status response. The token and ids are
// only populated once status is "confirmed".
type qrcodeStatusResp struct {
	Status   string `json:"status"`
	BotToken string `json:"bot_token"`
	BotID    string `json:"ilink_bot_id"`
	UserID   string `json:"ilink_user_id"`
	BaseURL  string `json:"baseurl"`
}

// login is the Connect-side scan-code binding (design/08 §4). It joins (or
// starts) a scan-login via StartLogin and blocks until the user confirms or the
// window elapses. Because it shares the session machinery with the panel's
// StartLogin, a panel-initiated login and Connect never run two QR binds at once.
func (a *Adapter) login(ctx context.Context) error {
	_, err := a.StartLogin(ctx)
	if errors.Is(err, ErrAlreadyLoggedIn) {
		return nil
	}
	if err != nil {
		return err
	}

	a.loginMu.Lock()
	sess := a.loginSession
	a.loginMu.Unlock()
	if sess == nil {
		return fmt.Errorf("weixin_ilink: login session missing")
	}

	select {
	case lerr := <-sess.done:
		return lerr
	case <-ctx.Done():
		sess.cancel()
		return fmt.Errorf("%w: %w", ErrLoginTimeout, ctx.Err())
	}
}

// runLogin polls get_qrcode_status until the QR is confirmed or the login window
// elapses, then records the outcome under the session. It runs in a goroutine so
// StartLogin returns immediately while the panel polls LoginStatus.
func (a *Adapter) runLogin(sess *loginSession, sessCtx context.Context) {
	timeoutCtx, cancel := context.WithTimeout(sessCtx, a.cfg.LoginTimeout)
	defer cancel()
	ticker := time.NewTicker(a.cfg.LoginInterval)
	defer ticker.Stop()

	for {
		status, err := a.pollQRStatus(timeoutCtx, sess.qrcode)
		if err != nil {
			// A deadline/cancel during the poll means the whole window elapsed;
			// surface ErrLoginTimeout rather than the raw transport error.
			if timeoutCtx.Err() != nil {
				a.failLogin(sess, fmt.Errorf("%w: %w", ErrLoginTimeout, timeoutCtx.Err()))
			} else {
				a.failLogin(sess, fmt.Errorf("weixin_ilink: poll qr status: %w", err))
			}
			return
		}
		if status.Status == "confirmed" && status.BotToken != "" {
			a.completeLogin(sess, status)
			return
		}
		select {
		case <-timeoutCtx.Done():
			a.failLogin(sess, fmt.Errorf("%w: %w", ErrLoginTimeout, timeoutCtx.Err()))
			return
		case <-ticker.C:
		}
	}
}

// completeLogin persists the confirmed credentials and marks the session live.
// It writes cfg under a.mu, then clears the session under loginMu (never nesting
// the two locks), and finally signals the waiting Connect path.
func (a *Adapter) completeLogin(sess *loginSession, status qrcodeStatusResp) {
	a.mu.Lock()
	a.cfg.BotToken = status.BotToken
	a.cfg.BotID = status.BotID
	a.cfg.OwnerID = status.UserID
	if status.BaseURL != "" {
		a.cfg.BaseURL = status.BaseURL
	}
	a.connected = true
	a.loginStatus = LoginStatusConfirmed
	a.loginDetail = ""
	a.mu.Unlock()

	a.loginMu.Lock()
	if a.loginSession == sess {
		a.loginSession = nil
	}
	a.loginMu.Unlock()

	sess.done <- nil
}

// failLogin records a failed scan-login and signals the waiting Connect path.
func (a *Adapter) failLogin(sess *loginSession, err error) {
	a.setLoginState(LoginStatusFailed, err.Error())

	a.loginMu.Lock()
	if a.loginSession == sess {
		a.loginSession = nil
	}
	a.loginMu.Unlock()

	sess.done <- err
}

// fetchQRCode requests a new bot login QR code.
func (a *Adapter) fetchQRCode(ctx context.Context) (qrcodeResp, error) {
	path := a.apiURL("/ilink/bot/get_bot_qrcode?bot_type=" + strconv.Itoa(botType))
	var out qrcodeResp
	if err := a.doJSON(ctx, http.MethodGet, path, nil, &out); err != nil {
		return qrcodeResp{}, err
	}
	if out.Qrcode == "" {
		return qrcodeResp{}, fmt.Errorf("weixin_ilink: get_bot_qrcode returned empty qrcode")
	}
	return out, nil
}

// pollQRStatus checks whether a QR code has been confirmed.
func (a *Adapter) pollQRStatus(ctx context.Context, qrcode string) (qrcodeStatusResp, error) {
	path := a.apiURL("/ilink/bot/get_qrcode_status?qrcode=" + url.QueryEscape(qrcode))
	var out qrcodeStatusResp
	if err := a.doJSON(ctx, http.MethodGet, path, nil, &out); err != nil {
		return qrcodeStatusResp{}, err
	}
	return out, nil
}