package bilibili

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"strconv"
	"strings"
	"time"

	"everypublish/server/internal/credentials"
	"everypublish/server/internal/platform"
)

// Adapter implements the server-side Bilibili API boundary. The exported
// endpoint fields make the adapter straightforward to use with an httptest
// server while retaining production defaults in New.
type Adapter struct {
	Store        *credentials.Store
	Credentials  *credentials.Store // compatibility alias for callers using this name
	HTTP         *http.Client
	MemberBase   string
	PassportBase string
	UpOSScheme   string
	PollTimeout  time.Duration
	PollInterval time.Duration
	MaxRetries   int
}

func New(store *credentials.Store) *Adapter {
	return &Adapter{Store: store, Credentials: store, HTTP: &http.Client{Timeout: 30 * time.Second},
		MemberBase: "https://member.bilibili.com", PassportBase: "https://passport.bilibili.com",
		UpOSScheme: "https", PollTimeout: 3 * time.Minute, PollInterval: 2 * time.Second, MaxRetries: 2}
}

func (a *Adapter) Platform() string { return "bilibili" }

func (a *Adapter) BeginLogin(ctx context.Context) (platform.LoginSession, error) {
	var ret struct {
		Code int `json:"code"`
		Data struct {
			URL string `json:"url"`
			Key string `json:"qrcode_key"`
		} `json:"data"`
	}
	if err := a.getJSON(ctx, a.passportBase()+"/x/passport-login/web/qrcode/generate", "", &ret); err != nil {
		return platform.LoginSession{}, err
	}
	if ret.Code != 0 || ret.Data.Key == "" || ret.Data.URL == "" {
		return platform.LoginSession{}, perr(platform.PlatformChanged, "invalid QR response", nil)
	}
	return platform.LoginSession{Token: ret.Data.Key, URL: ret.Data.URL}, nil
}

func (a *Adapter) PollLogin(ctx context.Context, token string) (platform.LoginPoll, error) {
	if token == "" {
		return platform.LoginPoll{}, perr(platform.Validation, "QR token is empty", nil)
	}
	q := url.Values{"qrcode_key": []string{token}}
	var ret struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Data    struct {
			URL string `json:"url"`
		} `json:"data"`
	}
	if err := a.getJSON(ctx, a.passportBase()+"/x/passport-login/web/qrcode/poll?"+q.Encode(), "", &ret); err != nil {
		return platform.LoginPoll{}, err
	}
	switch ret.Code {
	case 86101:
		return platform.LoginPoll{State: platform.LoginPending, Prompt: "请使用哔哩哔哩手机客户端扫码"}, nil
	case 86090:
		return platform.LoginPoll{State: platform.LoginScanned, Prompt: "已扫码，请在哔哩哔哩手机客户端确认登录"}, nil
	case 0:
		cookies := cookiesFromURL(ret.Data.URL)
		if cookies == "" {
			return platform.LoginPoll{}, perr(platform.PlatformChanged, "login response did not contain cookies", nil)
		}
		return platform.LoginPoll{State: platform.LoginConfirmed, Cookies: cookies}, nil
	default:
		return platform.LoginPoll{}, perr(platform.PlatformChanged, "QR poll rejected: "+ret.Message, nil)
	}
}

func (a *Adapter) SaveCredentials(workspaceID, accountID uint64, cookies string) error {
	if strings.TrimSpace(cookies) == "" {
		return perr(platform.Validation, "cookies are empty", nil)
	}
	if cookieValue(cookies, "SESSDATA") == "" || cookieValue(cookies, "bili_jct") == "" || cookieValue(cookies, "DedeUserID") == "" {
		return perr(platform.Validation, "Bilibili cookies must include SESSDATA, bili_jct and DedeUserID", nil)
	}
	s := a.store()
	if s == nil {
		return perr(platform.Unknown, "credential store is not configured", nil)
	}
	if err := s.Save(workspaceID, accountID, []byte(cookies)); err != nil {
		return perr(platform.Unknown, "saving credentials", err)
	}
	return nil
}

func (a *Adapter) CheckCredentials(ctx context.Context, workspaceID, accountID uint64) error {
	s := a.store()
	if s == nil {
		return perr(platform.Unknown, "credential store is not configured", nil)
	}
	raw, err := s.Load(workspaceID, accountID)
	if err != nil {
		return perr(platform.AuthRequired, "credentials are unavailable", err)
	}
	var ret struct {
		Code int `json:"code"`
		Data struct {
			IsLogin bool `json:"isLogin"`
		} `json:"data"`
	}
	if err := a.getJSON(ctx, a.memberBase()+"/x/web-interface/nav", string(raw), &ret); err != nil {
		return err
	}
	if ret.Code != 0 || !ret.Data.IsLogin {
		return perr(platform.AuthRequired, "Bilibili login has expired", nil)
	}
	return nil
}

func (a *Adapter) Publish(ctx context.Context, in platform.PublishInput) (platform.PublishResult, error) {
	s := a.store()
	if s == nil {
		return platform.PublishResult{}, perr(platform.Unknown, "credential store is not configured", nil)
	}
	raw, err := s.Load(in.WorkspaceID, in.AccountID)
	if err != nil {
		return platform.PublishResult{}, perr(platform.AuthRequired, "credentials are unavailable", err)
	}
	if len(in.MaterialURLs) == 0 {
		return platform.PublishResult{}, perr(platform.Validation, "material is required", nil)
	}
	if len(in.MaterialURLs) > 1 {
		return platform.PublishResult{}, perr(platform.Validation, "Bilibili currently accepts one video per task", nil)
	}
	path, cleanup, err := a.download(ctx, in.MaterialURLs[0])
	if err != nil {
		return platform.PublishResult{}, err
	}
	defer cleanup()
	part, err := a.upload(ctx, string(raw), path)
	if err != nil {
		return platform.PublishResult{}, err
	}
	bvid, err := a.submit(ctx, string(raw), in, part)
	if err != nil {
		return platform.PublishResult{}, err
	}
	if bvid == "" {
		return platform.PublishResult{}, perr(platform.PlatformChanged, "submission did not return bvid", nil)
	}
	return platform.PublishResult{URL: "https://www.bilibili.com/video/" + bvid, Receipt: bvid}, nil
}

func (a *Adapter) download(ctx context.Context, rawURL string) (string, func(), error) {
	raw, err := a.request(ctx, http.MethodGet, rawURL, "", nil, nil)
	if err != nil {
		return "", nil, err
	}
	f, err := os.CreateTemp("", "ep-bilibili-*")
	if err != nil {
		return "", nil, perr(platform.Unknown, "creating temporary material", err)
	}
	name := f.Name()
	if _, err = f.Write(raw); err != nil {
		f.Close()
		os.Remove(name)
		return "", nil, perr(platform.Network, "saving material", err)
	}
	if err = f.Close(); err != nil {
		os.Remove(name)
		return "", nil, perr(platform.Network, "saving material", err)
	}
	return name, func() { _ = os.Remove(name) }, nil
}

func (a *Adapter) upload(ctx context.Context, cookies, path string) (map[string]interface{}, error) {
	st, err := os.Stat(path)
	if err != nil {
		return nil, perr(platform.Validation, "material unavailable", err)
	}
	name, total := filepath.Base(path), st.Size()
	if total <= 0 {
		return nil, perr(platform.Validation, "material is empty", nil)
	}
	q := url.Values{"r": {"upos"}, "profile": {"ugcupos/bup"}, "ssl": {"0"}, "version": {"2.8.12"}, "build": {"2081200"}, "name": {name}, "size": {strconv.FormatInt(total, 10)}}
	var pre struct {
		OK        int    `json:"OK"`
		Endpoint  string `json:"endpoint"`
		Auth      string `json:"auth"`
		BizID     int    `json:"biz_id"`
		UposURI   string `json:"upos_uri"`
		ChunkSize int    `json:"chunk_size"`
	}
	if err := a.getJSON(ctx, a.memberBase()+"/preupload?upcdn=bda2&probe_version=20221109&"+q.Encode(), cookies, &pre); err != nil {
		return nil, err
	}
	if pre.OK != 1 || pre.Endpoint == "" || pre.UposURI == "" {
		return nil, perr(platform.PlatformChanged, "invalid preupload response", nil)
	}
	upURL := a.upURL(pre.Endpoint, pre.UposURI)
	var up struct {
		UploadID string `json:"upload_id"`
	}
	if err := a.postJSON(ctx, upURL+"?uploads&output=json", cookies, map[string]string{"X-Upos-Auth": pre.Auth}, nil, &up); err != nil {
		return nil, err
	}
	if up.UploadID == "" {
		return nil, perr(platform.PlatformChanged, "upload id missing", nil)
	}
	chunk := pre.ChunkSize
	if chunk <= 0 {
		chunk = 7 * 1024 * 1024
	}
	count := int((total + int64(chunk) - 1) / int64(chunk))
	f, err := os.Open(path)
	if err != nil {
		return nil, perr(platform.Validation, "material unavailable", err)
	}
	defer f.Close()
	parts := make([]map[string]interface{}, 0, count)
	buf := make([]byte, chunk)
	for i := 0; i < count; i++ {
		n, er := io.ReadFull(f, buf)
		if er != nil && er != io.ErrUnexpectedEOF && er != io.EOF {
			return nil, perr(platform.Network, "reading material", er)
		}
		pq := url.Values{"uploadId": {up.UploadID}, "partNumber": {strconv.Itoa(i + 1)}, "chunk": {strconv.Itoa(i)}, "chunks": {strconv.Itoa(count)}, "size": {strconv.Itoa(n)}, "start": {strconv.Itoa(i * chunk)}, "end": {strconv.Itoa(i*chunk + n)}, "total": {strconv.FormatInt(total, 10)}}
		etag, err := a.put(ctx, upURL+"?"+pq.Encode(), cookies, map[string]string{"X-Upos-Auth": pre.Auth}, buf[:n])
		if err != nil {
			return nil, fmt.Errorf("%w: part %d", err, i+1)
		}
		if etag == "" {
			return nil, perr(platform.PlatformChanged, "upload response missing ETag", nil)
		}
		parts = append(parts, map[string]interface{}{"partNumber": i + 1, "eTag": etag})
	}
	mq := url.Values{"name": {name}, "uploadId": {up.UploadID}, "biz_id": {strconv.Itoa(pre.BizID)}, "output": {"json"}, "profile": {"ugcupos/bup"}}
	var merged struct {
		OK int `json:"OK"`
	}
	if err := a.postJSON(ctx, upURL+"?"+mq.Encode(), cookies, map[string]string{"X-Upos-Auth": pre.Auth}, map[string]interface{}{"parts": parts}, &merged); err != nil {
		return nil, err
	}
	if merged.OK != 1 {
		return nil, perr(platform.PlatformChanged, "merge failed", nil)
	}
	base := strings.TrimSuffix(filepath.Base(pre.UposURI), filepath.Ext(filepath.Base(pre.UposURI)))
	return map[string]interface{}{"title": strings.TrimSuffix(name, filepath.Ext(name)), "filename": base, "desc": ""}, nil
}

func (a *Adapter) submit(ctx context.Context, cookies string, in platform.PublishInput, part map[string]interface{}) (string, error) {
	tag := strings.Join(in.Tags, ",")
	if tag == "" {
		tag = "日常"
	}
	tid := in.CategoryID
	if tid <= 0 {
		tid = 174
	}
	body := map[string]interface{}{"title": truncate(in.Title, 80), "desc": in.Content, "desc_v2": []map[string]interface{}{{"raw_text": in.Content, "type": 1, "biz_id": ""}}, "copyright": 1, "source": "", "tid": tid, "tag": tag, "dynamic": "", "videos": []map[string]interface{}{part}}
	q := url.Values{"csrf": {cookieValue(cookies, "bili_jct")}}
	var ret struct {
		Code    int    `json:"code"`
		Message string `json:"message"`
		Data    struct {
			Bvid string `json:"bvid"`
		} `json:"data"`
	}
	if err := a.postJSON(ctx, a.memberBase()+"/x/vu/web/add?"+q.Encode(), cookies, nil, body, &ret); err != nil {
		return "", err
	}
	if ret.Code != 0 {
		return "", perr(platform.Validation, ret.Message, nil)
	}
	return ret.Data.Bvid, nil
}

func (a *Adapter) getJSON(ctx context.Context, rawURL, cookies string, out interface{}) error {
	raw, err := a.request(ctx, http.MethodGet, rawURL, cookies, nil, nil)
	if err != nil {
		return err
	}
	if err := json.Unmarshal(raw, out); err != nil {
		return perr(platform.PlatformChanged, "invalid JSON response", err)
	}
	return nil
}

func (a *Adapter) postJSON(ctx context.Context, rawURL, cookies string, headers map[string]string, body, out interface{}) error {
	var data io.Reader
	if body != nil {
		raw, err := json.Marshal(body)
		if err != nil {
			return perr(platform.Validation, "invalid request", err)
		}
		data = bytes.NewReader(raw)
	}
	raw, err := a.request(ctx, http.MethodPost, rawURL, cookies, headers, data)
	if err != nil {
		return err
	}
	if out != nil {
		if err := json.Unmarshal(raw, out); err != nil {
			return perr(platform.PlatformChanged, "invalid JSON response", err)
		}
	}
	return nil
}

func (a *Adapter) put(ctx context.Context, rawURL, cookies string, headers map[string]string, body []byte) (string, error) {
	for attempt := 0; attempt <= a.retries(); attempt++ {
		if err := ctx.Err(); err != nil {
			return "", err
		}
		req, err := http.NewRequestWithContext(ctx, http.MethodPut, rawURL, bytes.NewReader(body))
		if err != nil {
			return "", perr(platform.Validation, "invalid URL", err)
		}
		if cookies != "" {
			req.Header.Set("Cookie", cookies)
		}
		req.Header.Set("User-Agent", "Mozilla/5.0")
		req.Header.Set("Referer", "https://member.bilibili.com")
		for k, v := range headers {
			req.Header.Set(k, v)
		}
		resp, err := a.client().Do(req)
		if err != nil {
			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
				return "", err
			}
			if attempt < a.retries() {
				if !sleep(ctx, retryDelay(attempt)) {
					return "", ctx.Err()
				}
				continue
			}
			return "", perr(platform.Network, "network request failed", err)
		}
		_, readErr := io.Copy(io.Discard, resp.Body)
		resp.Body.Close()
		if readErr != nil {
			return "", perr(platform.Network, "reading response", readErr)
		}
		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
			if resp.StatusCode >= 500 && attempt < a.retries() {
				if !sleep(ctx, retryDelay(attempt)) {
					return "", ctx.Err()
				}
				continue
			}
			cat := platform.Unknown
			if resp.StatusCode == 401 || resp.StatusCode == 403 {
				cat = platform.AuthRequired
			}
			if resp.StatusCode == 429 {
				cat = platform.RateLimited
			}
			if resp.StatusCode >= 500 {
				cat = platform.Network
			}
			return "", perr(cat, "HTTP "+strconv.Itoa(resp.StatusCode), nil)
		}
		return strings.Trim(resp.Header.Get("ETag"), "\""), nil
	}
	return "", perr(platform.Network, "upload failed", nil)
}

func (a *Adapter) request(ctx context.Context, method, rawURL, cookies string, headers map[string]string, body io.Reader) ([]byte, error) {
	var payload []byte
	var err error
	if body != nil {
		payload, err = io.ReadAll(body)
		if err != nil {
			return nil, perr(platform.Network, "reading request body", err)
		}
	}
	var last error
	for attempt := 0; attempt <= a.retries(); attempt++ {
		if err := ctx.Err(); err != nil {
			return nil, err
		}
		var reqBody io.Reader
		if body != nil {
			reqBody = bytes.NewReader(payload)
		}
		req, err := http.NewRequestWithContext(ctx, method, rawURL, reqBody)
		if err != nil {
			return nil, perr(platform.Validation, "invalid URL", err)
		}
		if cookies != "" {
			req.Header.Set("Cookie", cookies)
		}
		req.Header.Set("User-Agent", "Mozilla/5.0")
		req.Header.Set("Referer", "https://member.bilibili.com")
		if body != nil && method == http.MethodPost {
			req.Header.Set("Content-Type", "application/json")
		}
		for k, v := range headers {
			req.Header.Set(k, v)
		}
		resp, err := a.client().Do(req)
		if err != nil {
			if errors.Is(err, context.Canceled) || errors.Is(err, context.DeadlineExceeded) {
				return nil, err
			}
			last = perr(platform.Network, "network request failed", err)
			if attempt < a.retries() {
				if !sleep(ctx, retryDelay(attempt)) {
					return nil, ctx.Err()
				}
				continue
			}
			return nil, last
		}
		raw, readErr := io.ReadAll(io.LimitReader(resp.Body, 16<<20))
		resp.Body.Close()
		if readErr != nil {
			return nil, perr(platform.Network, "reading response", readErr)
		}
		if resp.StatusCode < 200 || resp.StatusCode >= 300 {
			cat := platform.Unknown
			if resp.StatusCode == 401 || resp.StatusCode == 403 {
				cat = platform.AuthRequired
			}
			if resp.StatusCode == 429 {
				cat = platform.RateLimited
			}
			if resp.StatusCode >= 500 {
				cat = platform.Network
			}
			last = perr(cat, "HTTP "+strconv.Itoa(resp.StatusCode), nil)
			if resp.StatusCode >= 500 && attempt < a.retries() {
				if !sleep(ctx, retryDelay(attempt)) {
					return nil, ctx.Err()
				}
				continue
			}
			return nil, last
		}
		return raw, nil
	}
	return nil, last
}

func (a *Adapter) client() *http.Client {
	if a.HTTP != nil {
		return a.HTTP
	}
	return http.DefaultClient
}
func (a *Adapter) retries() int {
	if a.MaxRetries < 0 {
		return 0
	}
	if a.MaxRetries == 0 {
		return 2
	}
	return a.MaxRetries
}
func retryDelay(n int) time.Duration { return time.Duration(25*(1<<n)) * time.Millisecond }
func sleep(ctx context.Context, d time.Duration) bool {
	t := time.NewTimer(d)
	defer t.Stop()
	select {
	case <-ctx.Done():
		return false
	case <-t.C:
		return true
	}
}
func (a *Adapter) memberBase() string {
	if a.MemberBase != "" {
		return strings.TrimRight(a.MemberBase, "/")
	}
	return "https://member.bilibili.com"
}
func (a *Adapter) passportBase() string {
	if a.PassportBase != "" {
		return strings.TrimRight(a.PassportBase, "/")
	}
	return "https://passport.bilibili.com"
}
func (a *Adapter) store() *credentials.Store {
	if a.Store != nil {
		return a.Store
	}
	return a.Credentials
}
func (a *Adapter) upURL(endpoint, uri string) string {
	scheme := a.UpOSScheme
	if scheme == "" {
		scheme = "https"
	}
	if strings.HasPrefix(endpoint, "http://") || strings.HasPrefix(endpoint, "https://") {
		return strings.TrimRight(endpoint, "/") + "/" + strings.TrimPrefix(uri, "upos://")
	}
	return scheme + "://" + strings.TrimRight(strings.TrimPrefix(endpoint, "//"), "/") + "/" + strings.TrimPrefix(uri, "upos://")
}

// cookiesFromURL extracts only the three cookies accepted by Bilibili's
// cross-domain login redirect; all query values are URL-decoded by net/url.
func cookiesFromURL(raw string) string {
	u, err := url.Parse(raw)
	if err != nil {
		return ""
	}
	q := u.Query()
	sess := q.Get("SESSDATA")
	csrf := q.Get("bili_jct")
	uid := q.Get("DedeUserID")
	if sess == "" || csrf == "" || uid == "" {
		return ""
	}
	return "SESSDATA=" + sess + "; bili_jct=" + csrf + "; DedeUserID=" + uid
}
func cookieValue(cookies, key string) string {
	for _, p := range strings.Split(cookies, ";") {
		p = strings.TrimSpace(p)
		i := strings.IndexByte(p, '=')
		if i > 0 && p[:i] == key {
			return p[i+1:]
		}
	}
	return ""
}
func truncate(s string, n int) string {
	r := []rune(s)
	if len(r) > n {
		return string(r[:n])
	}
	return s
}
func perr(cat platform.ErrorCategory, msg string, err error) error {
	return &platform.Error{Category: cat, Message: msg, Err: err}
}