package forge

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

// GitHubAPIBaseURL is the root of the github.com REST API.
const GitHubAPIBaseURL = "https://api.github.com"

// gitHubAPIVersion pins the GitHub REST API version, so a newer default version cannot change response shapes under spx.
const gitHubAPIVersion = "2022-11-28"

// restForge is the [Forge] for both Gitea and GitHub: their REST endpoints for issues, comments and pull requests
// share paths and JSON shapes, so the two differ only in API root, auth headers, page-size parameter and where a pull
// request names its branches.
type restForge struct {
	kind      Kind
	apiBase   string
	owner     string
	repo      string
	header    http.Header
	pageParam string
	pageSize  int
	// branchOf reads the branch name out of a pull request's `head` or `base`.
	branchOf func(apiBranchRef) string
	http     *http.Client
}

// NewGitea returns the [Forge] for repo `owner`/`repo` on the Gitea instance at `baseURL`, e.g. `https://gitea.example.com`.
//
// Gitea serves at most 50 items per page by default (`MAX_RESPONSE_ITEMS`), so lists ask for that many.
func NewGitea(baseURL, token, owner, repo string) Forge {
	h := http.Header{}
	h.Set("Authorization", "token "+token)
	h.Set("Accept", "application/json")
	return &restForge{
		kind:      KindGitea,
		apiBase:   strings.TrimRight(baseURL, "/") + "/api/v1",
		owner:     owner,
		repo:      repo,
		header:    h,
		pageParam: "limit",
		pageSize:  50,
		branchOf:  giteaBranch,
		http:      &http.Client{Timeout: 30 * time.Second},
	}
}

// NewGitHub returns the [Forge] for repo `owner`/`repo` on GitHub, whose REST API sits at `apiBaseURL`, normally [GitHubAPIBaseURL].
func NewGitHub(apiBaseURL, token, owner, repo string) Forge {
	h := http.Header{}
	h.Set("Authorization", "Bearer "+token)
	h.Set("Accept", "application/vnd.github+json")
	h.Set("X-GitHub-Api-Version", gitHubAPIVersion)
	return &restForge{
		kind:      KindGitHub,
		apiBase:   strings.TrimRight(apiBaseURL, "/"),
		owner:     owner,
		repo:      repo,
		header:    h,
		pageParam: "per_page",
		pageSize:  100,
		branchOf:  func(r apiBranchRef) string { return r.Ref },
		http:      &http.Client{Timeout: 30 * time.Second},
	}
}

func (f *restForge) Kind() Kind { return f.kind }

// repoURL builds the API URL of `suffix` under this repo, e.g. `/issues/3` becomes `<api>/repos/<owner>/<repo>/issues/3`.
func (f *restForge) repoURL(suffix string) string {
	return f.apiBase + "/repos/" + f.owner + "/" + f.repo + suffix
}

// do sends one authenticated request to `rawURL`, sending `payload` as the JSON body when not nil, and decodes the
// JSON response into `out` when not nil.
//
// @return the response headers, so list calls can read the `Link` header for the next page
func (f *restForge) do(method, rawURL string, payload, out any) (http.Header, error) {
	var body io.Reader
	if payload != nil {
		buf, err := json.Marshal(payload)
		if err != nil {
			return nil, fmt.Errorf("编码请求体失败: %w", err)
		}
		body = bytes.NewReader(buf)
	}
	req, err := http.NewRequest(method, rawURL, body)
	if err != nil {
		return nil, fmt.Errorf("构造请求失败: %w", err)
	}
	for k, v := range f.header {
		req.Header[k] = v
	}
	if payload != nil {
		req.Header.Set("Content-Type", "application/json")
	}
	resp, err := f.http.Do(req)
	if err != nil {
		return nil, fmt.Errorf("%s %s 请求失败: %w", method, rawURL, err)
	}
	defer resp.Body.Close()
	respBytes, _ := io.ReadAll(resp.Body)
	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
		return nil, fmt.Errorf("%s %s 返回 %d: %s", method, rawURL, resp.StatusCode, strings.TrimSpace(string(respBytes)))
	}
	if out != nil && len(respBytes) > 0 {
		if err := json.Unmarshal(respBytes, out); err != nil {
			return nil, fmt.Errorf("解析响应失败 (%s %s): %w; body=%s", method, rawURL, err, string(respBytes))
		}
	}
	return resp.Header, nil
}

// listAll reads every page of the list at `rawURL`, asking for the largest page size and then following each
// `Link: rel="next"` header until there is none.
//
// An endpoint that does not paginate, such as Gitea's issue comments, sends everything with no `Link`, so one request is enough.
func listAll[T any](f *restForge, rawURL string) ([]T, error) {
	u, err := url.Parse(rawURL)
	if err != nil {
		return nil, fmt.Errorf("构造列表 URL 失败: %w", err)
	}
	q := u.Query()
	q.Set(f.pageParam, strconv.Itoa(f.pageSize))
	u.RawQuery = q.Encode()
	var all []T
	for next := u.String(); next != ""; {
		var page []T
		header, err := f.do(http.MethodGet, next, nil, &page)
		if err != nil {
			return nil, err
		}
		all = append(all, page...)
		if next, err = f.nextPage(next, header.Get("Link")); err != nil {
			return nil, err
		}
	}
	return all, nil
}

// nextPage resolves the `rel="next"` URL of a `Link` header against the page just read, or returns "" on the last page.
//
// It refuses a next URL on another scheme or host than the API root, so the token is never sent anywhere else.
func (f *restForge) nextPage(current, linkHeader string) (string, error) {
	target := nextLink(linkHeader)
	if target == "" {
		return "", nil
	}
	cur, err := url.Parse(current)
	if err != nil {
		return "", fmt.Errorf("解析当前页 URL %q 失败: %w", current, err)
	}
	ref, err := url.Parse(target)
	if err != nil {
		return "", fmt.Errorf("解析分页链接 %q 失败: %w", target, err)
	}
	abs := cur.ResolveReference(ref)
	base, err := url.Parse(f.apiBase)
	if err != nil {
		return "", fmt.Errorf("解析 API 根地址 %q 失败: %w", f.apiBase, err)
	}
	if !strings.EqualFold(abs.Scheme, base.Scheme) || !strings.EqualFold(abs.Host, base.Host) {
		return "", fmt.Errorf("分页链接 %s 不在 API 地址 %s 下，拒绝带 token 访问", abs, f.apiBase)
	}
	return abs.String(), nil
}

// linkEntryRegex matches one `<url>; params` entry of a `Link` header; the params run until the next `<`.
var linkEntryRegex = regexp.MustCompile(`<([^>]*)>([^<]*)`)

// nextLink picks the URL marked `rel="next"` out of a `Link` header, or returns "" when there is none.
func nextLink(header string) string {
	for _, m := range linkEntryRegex.FindAllStringSubmatch(header, -1) {
		for _, param := range strings.Split(m[2], ";") {
			name, value, ok := strings.Cut(strings.TrimSpace(strings.TrimRight(strings.TrimSpace(param), ",")), "=")
			if !ok || !strings.EqualFold(strings.TrimSpace(name), "rel") {
				continue
			}
			for _, rel := range strings.Fields(strings.Trim(strings.TrimSpace(value), `"`)) {
				if strings.EqualFold(rel, "next") {
					return m[1]
				}
			}
		}
	}
	return ""
}

// apiUser, apiIssue, apiComment and apiPull mirror the response fields spx reads; Gitea and GitHub name them alike.
type apiUser struct {
	Login string `json:"login"`
}

type apiIssue struct {
	Number    int       `json:"number"`
	Title     string    `json:"title"`
	Body      string    `json:"body"`
	State     string    `json:"state"`
	HTMLURL   string    `json:"html_url"`
	User      apiUser   `json:"user"`
	Assignees []apiUser `json:"assignees"`
}

func (a apiIssue) issue() *Issue {
	assignees := make([]string, 0, len(a.Assignees))
	for _, u := range a.Assignees {
		assignees = append(assignees, u.Login)
	}
	return &Issue{
		Number:    a.Number,
		Title:     a.Title,
		Body:      a.Body,
		State:     a.State,
		Author:    a.User.Login,
		Assignees: assignees,
		HTMLURL:   a.HTMLURL,
	}
}

type apiComment struct {
	ID        int64   `json:"id"`
	Body      string  `json:"body"`
	HTMLURL   string  `json:"html_url"`
	CreatedAt string  `json:"created_at"`
	User      apiUser `json:"user"`
}

func (a apiComment) comment() Comment {
	return Comment{ID: a.ID, Author: a.User.Login, Body: a.Body, CreatedAt: a.CreatedAt, HTMLURL: a.HTMLURL}
}

type apiBranchRef struct {
	Label string `json:"label"`
	Ref   string `json:"ref"`
	SHA   string `json:"sha"`
}

// giteaBranch reads the branch name the way Gitea reports it: `label` is always the branch, while `ref` becomes
// `refs/pull/<n>/head` once the branch is deleted. AGit pull requests leave `label` empty, so `ref` is the fallback.
func giteaBranch(r apiBranchRef) string {
	if r.Label != "" {
		return r.Label
	}
	return r.Ref
}

type apiPull struct {
	Number  int          `json:"number"`
	Title   string       `json:"title"`
	Body    string       `json:"body"`
	State   string       `json:"state"`
	Merged  bool         `json:"merged"`
	HTMLURL string       `json:"html_url"`
	User    apiUser      `json:"user"`
	Head    apiBranchRef `json:"head"`
	Base    apiBranchRef `json:"base"`
}

// pull converts the response, naming branches with this forge's `branchOf`.
func (f *restForge) pull(a apiPull) *PullRequest {
	return &PullRequest{
		Number:  a.Number,
		Title:   a.Title,
		Body:    a.Body,
		State:   a.State,
		Merged:  a.Merged,
		Author:  a.User.Login,
		Head:    BranchRef{Branch: f.branchOf(a.Head), SHA: a.Head.SHA},
		Base:    BranchRef{Branch: f.branchOf(a.Base), SHA: a.Base.SHA},
		HTMLURL: a.HTMLURL,
	}
}

func (f *restForge) CurrentUserLogin() (string, error) {
	var out apiUser
	if _, err := f.do(http.MethodGet, f.apiBase+"/user", nil, &out); err != nil {
		return "", err
	}
	return out.Login, nil
}

func (f *restForge) CreateIssue(title, body string, assignees []string) (*Issue, error) {
	payload := map[string]any{"title": title, "body": body}
	if len(assignees) > 0 {
		payload["assignees"] = assignees
	}
	var out apiIssue
	if _, err := f.do(http.MethodPost, f.repoURL("/issues"), payload, &out); err != nil {
		return nil, err
	}
	return out.issue(), nil
}

func (f *restForge) GetIssue(number int) (*Issue, error) {
	var out apiIssue
	if _, err := f.do(http.MethodGet, f.repoURL(fmt.Sprintf("/issues/%d", number)), nil, &out); err != nil {
		return nil, err
	}
	return out.issue(), nil
}

func (f *restForge) UpdateIssueBody(number int, body string) error {
	_, err := f.do(http.MethodPatch, f.repoURL(fmt.Sprintf("/issues/%d", number)), map[string]any{"body": body}, nil)
	return err
}

func (f *restForge) ListIssueComments(number int) ([]Comment, error) {
	raw, err := listAll[apiComment](f, f.repoURL(fmt.Sprintf("/issues/%d/comments", number)))
	if err != nil {
		return nil, err
	}
	out := make([]Comment, 0, len(raw))
	for _, c := range raw {
		out = append(out, c.comment())
	}
	return out, nil
}

func (f *restForge) CreateIssueComment(number int, body string) (*Comment, error) {
	var out apiComment
	if _, err := f.do(http.MethodPost, f.repoURL(fmt.Sprintf("/issues/%d/comments", number)), map[string]any{"body": body}, &out); err != nil {
		return nil, err
	}
	c := out.comment()
	return &c, nil
}

func (f *restForge) GetPullRequest(number int) (*PullRequest, error) {
	var out apiPull
	if _, err := f.do(http.MethodGet, f.repoURL(fmt.Sprintf("/pulls/%d", number)), nil, &out); err != nil {
		return nil, err
	}
	return f.pull(out), nil
}

func (f *restForge) CreatePullRequest(pr NewPullRequest) (*PullRequest, error) {
	payload := map[string]any{"title": pr.Title, "body": pr.Body, "head": pr.Head, "base": pr.Base}
	var out apiPull
	if _, err := f.do(http.MethodPost, f.repoURL("/pulls"), payload, &out); err != nil {
		return nil, err
	}
	return f.pull(out), nil
}

func (f *restForge) DefaultBranch() (string, error) {
	var out struct {
		DefaultBranch string `json:"default_branch"`
	}
	if _, err := f.do(http.MethodGet, f.repoURL(""), nil, &out); err != nil {
		return "", err
	}
	if out.DefaultBranch == "" {
		return "", fmt.Errorf("仓库 %s/%s 没有返回默认分支", f.owner, f.repo)
	}
	return out.DefaultBranch, nil
}