package artifacts

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"
	"mime"
	"net/http"
	"net/url"
	"os"
	"strings"
	"time"
)

type ActionClient struct {
	*http.Client
	base  string
	token string
}

func NewActionClient() *ActionClient {
	c := &ActionClient{Client: &http.Client{}}
	c.base = os.Getenv("ACTIONS_RESULTS_URL")
	c.token = fmt.Sprintf("Bearer %s", os.Getenv("ACTIONS_RUNTIME_TOKEN"))
	return c
}

func (c *ActionClient) Do(req *http.Request) (*http.Response, error) {
	req.Header.Set("Authorization", c.token)
	if !req.URL.IsAbs() {
		u, err := url.Parse(fmt.Sprintf("%s%s", strings.TrimRight(c.base, "/"), req.URL))
		if err != nil {
			return nil, err
		}
		req.URL = u
	}
	return c.Client.Do(req)
}

func HasContentType(r *http.Response, mimetype string) bool {
	contentType := r.Header.Get("content-type")
	if contentType == "" {
		return mimetype == "application/octet-stream"
	}

	for _, v := range strings.Split(contentType, ",") {
		t, _, err := mime.ParseMediaType(v)
		if err != nil {
			break
		}
		if t == mimetype {
			return true
		}
	}
	return false
}

type ApiClient interface {
	Do(*http.Request) (*http.Response, error)
}

type GitHub struct {
	client ApiClient
}

func NewGitHub(client ApiClient) *GitHub {
	return &GitHub{client: client}
}

type CreateArtifactRequest struct {
	RunID    string `json:"workflowRunBackendId"`
	JobRunID string `json:"workflowJobRunBackendId"`
	Name     string `json:"name"`
	Version  int32  `json:"version"`

	ExpiresAt *time.Time `json:"expiresAt,omitempty"`
}

type CreateArtifactResponse struct {
	Ok              bool   `json:"ok"`
	SignedUploadUrl string `json:"signedUploadUrl"`
}

type FinalizeArtifactRequest struct {
	RunID    string `json:"workflowRunBackendId"`
	JobRunID string `json:"workflowJobRunBackendId"`
	Name     string `json:"name"`
	Size     int64  `json:"size"`
	Hash     string `json:"hash,omitempty"`
}

type FinalizeArtifactResponse struct {
	Ok         bool   `json:"ok"`
	ArtifactId string `json:"artifactId"`
}

type ListArtifactsRequest struct {
	RunID      string `json:"workflowRunBackendId"`
	JobRunID   string `json:"workflowJobRunBackendId"`
	NameFilter string `json:"nameFilter"`
	IdFilter   string `json:"idFilter"`
}

type ListArtifactsResponse struct {
	Artifacts []struct {
		RunID     string     `json:"workflowRunBackendId"`
		JobRunID  string     `json:"workflowJobRunBackendId"`
		Id        string     `json:"databaseId"`
		Name      string     `json:"name"`
		Size      string     `json:"size"`
		CreatedAt *time.Time `json:"createdAt"`
		Digest    string     `json:"digest"`
	} `json:"artifacts"`
}

type GetSignedArtifactURLRequest struct {
	RunID    string `json:"workflowRunBackendId"`
	JobRunID string `json:"workflowJobRunBackendId"`
	Name     string `json:"name"`
}

type GetSignedArtifactURLResponse struct {
	SignedUrl string `json:"signedUrl"`
}

type DeleteArtifactRequest struct {
	RunID    string `json:"workflowRunBackendId"`
	JobRunID string `json:"workflowJobRunBackendId"`
	Name     string `json:"name"`
}

type DeleteArtifactResponse struct {
	Ok         bool   `json:"ok"`
	ArtifactId string `json:"artifactId"`
}

func (gh *GitHub) CreateArtifact(ctx context.Context, req CreateArtifactRequest) (*CreateArtifactResponse, error) {
	endpoint := "/twirp/github.actions.results.api.v1.ArtifactService/CreateArtifact"
	var result CreateArtifactResponse
	if err := gh.twirp(ctx, endpoint, req, &result); err != nil {
		return nil, err
	}
	return &result, nil
}

func (gh *GitHub) FinalizeArtifact(ctx context.Context, req FinalizeArtifactRequest) (*FinalizeArtifactResponse, error) {
	endpoint := "/twirp/github.actions.results.api.v1.ArtifactService/FinalizeArtifact"
	var result FinalizeArtifactResponse
	if err := gh.twirp(ctx, endpoint, req, &result); err != nil {
		return nil, err
	}
	return &result, nil
}

func (gh *GitHub) twirp(ctx context.Context, url string, in any, out any) error {
	var b bytes.Buffer

	if err := json.NewEncoder(&b).Encode(in); err != nil {
		return err
	}

	req, err := http.NewRequestWithContext(ctx, http.MethodPost, url, &b)
	if err != nil {
		return err
	}
	req.Header.Set("content-type", "application/json")
	req.Header.Set("accept", "application/json")

	res, err := gh.client.Do(req)
	if err != nil {
		return err
	}
	defer res.Body.Close()
	if !HasContentType(res, "application/json") {
		return fmt.Errorf("content-type: %q should be %q",
			res.Header.Get("content-type"), "application/json")
	}
	dec := json.NewDecoder(io.LimitReader(res.Body, 32*1024))

	if res.StatusCode >= 200 && res.StatusCode < 300 {
		return dec.Decode(out)
	} else {
		body, _ := io.ReadAll(res.Body)
		return fmt.Errorf("twirp call %s failed: %d: %s", url, res.StatusCode, string(body))
	}
}