package oss

import (
	"context"
	"errors"
	"io"
	"net/http"
	"strconv"
	"time"

	"git.yuntuo.hk/k2safe/go-omni/storage"
	sdk "github.com/aliyun/alibabacloud-oss-go-sdk-v2/oss"
)

// PresignPut requires an OSS V4 client configured with
// WithAdditionalHeaders([]string{"content-length"}). Missing signed constraints
// fail closed; the borrowed client is never mutated by this adapter.
func (s *Store) PresignPut(ctx context.Context, key string, size int64, contentType string, ttl time.Duration) (storage.UploadRequest, error) {
	if err := storage.CheckUpload(ctx, key, size, s.maxBytes, contentType, ttl); err != nil {
		return storage.UploadRequest{}, err
	}
	if size > 5<<30 {
		return storage.UploadRequest{}, storage.ErrTooLarge
	}
	if contentType == "" {
		contentType = "application/octet-stream"
	}
	r, err := s.client.Presign(ctx, &sdk.PutObjectRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(key), ContentLength: sdk.Ptr(size), ContentType: sdk.Ptr(contentType)}, sdk.PresignExpires(ttl))
	if err != nil {
		return storage.UploadRequest{}, err
	}
	return uploadRequest(r, size, contentType)
}
func uploadRequest(r *sdk.PresignResult, size int64, contentType string) (storage.UploadRequest, error) {
	headers := make(http.Header)
	for k, v := range r.SignedHeaders {
		headers.Set(k, v)
	}
	if headers.Get("Content-Length") != strconv.FormatInt(size, 10) || (contentType != "" && headers.Get("Content-Type") != contentType) {
		return storage.UploadRequest{}, errors.New("storage/oss: upload requires signed Content-Length and Content-Type; configure V4 and WithAdditionalHeaders(content-length)")
	}
	return storage.UploadRequest{Method: r.Method, URL: r.URL, Headers: headers, ExpiresAt: r.Expiration}, nil
}
func (s *Store) CreateMultipart(ctx context.Context, key, contentType string) (storage.MultipartUpload, error) {
	if err := storage.Check(ctx, key); err != nil {
		return storage.MultipartUpload{}, err
	}
	if _, err := storage.MediaType(contentType); err != nil {
		return storage.MultipartUpload{}, err
	}
	if contentType == "" {
		contentType = "application/octet-stream"
	}
	r, err := s.client.InitiateMultipartUpload(ctx, &sdk.InitiateMultipartUploadRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(key), ContentType: sdk.Ptr(contentType)})
	if err != nil {
		return storage.MultipartUpload{}, err
	}
	return storage.MultipartUpload{Key: key, UploadID: sdk.ToString(r.UploadId)}, nil
}
func (s *Store) UploadPart(ctx context.Context, upload storage.MultipartUpload, number int, body io.Reader, size int64) (storage.Part, error) {
	if err := storage.CheckPart(ctx, upload, number, size, s.maxBytes); err != nil {
		return storage.Part{}, err
	}
	reader, err := (storage.UploadPolicy{MaxBytes: s.maxBytes}).PrepareUpload(ctx, body, size, "")
	if err != nil {
		return storage.Part{}, err
	}
	r, err := s.client.UploadPart(ctx, &sdk.UploadPartRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID), PartNumber: int32(number), ContentLength: sdk.Ptr(size), Body: reader})
	if err != nil {
		return storage.Part{}, mapError(err)
	}
	return storage.Part{Number: number, ETag: sdk.ToString(r.ETag), Size: size}, nil
}
func (s *Store) PresignPart(ctx context.Context, upload storage.MultipartUpload, number int, size int64, ttl time.Duration) (storage.UploadRequest, error) {
	if err := storage.CheckPart(ctx, upload, number, size, s.maxBytes); err != nil {
		return storage.UploadRequest{}, err
	}
	if err := storage.CheckUpload(ctx, upload.Key, size, s.maxBytes, "", ttl); err != nil {
		return storage.UploadRequest{}, err
	}
	r, err := s.client.Presign(ctx, &sdk.UploadPartRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID), PartNumber: int32(number), ContentLength: sdk.Ptr(size), RequestCommon: sdk.RequestCommon{Headers: map[string]string{"Content-Type": "application/octet-stream"}}}, sdk.PresignExpires(ttl))
	if err != nil {
		return storage.UploadRequest{}, err
	}
	return uploadRequest(r, size, "application/octet-stream")
}
func (s *Store) ListParts(ctx context.Context, upload storage.MultipartUpload, after, limit int) (storage.PartsPage, error) {
	if err := storage.CheckPartsPage(ctx, upload, after, limit); err != nil {
		return storage.PartsPage{}, err
	}
	r, err := s.client.ListParts(ctx, &sdk.ListPartsRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID), PartNumberMarker: int32(after), MaxParts: int32(limit)})
	if err != nil {
		return storage.PartsPage{}, err
	}
	page := storage.PartsPage{Parts: make([]storage.Part, 0, len(r.Parts))}
	for _, p := range r.Parts {
		page.Parts = append(page.Parts, storage.Part{Number: int(p.PartNumber), ETag: sdk.ToString(p.ETag), Size: p.Size})
	}
	if r.IsTruncated {
		page.NextMarker = int(r.NextPartNumberMarker)
	}
	return page, nil
}
func (s *Store) CompleteMultipart(ctx context.Context, upload storage.MultipartUpload, parts []storage.Part) (storage.Info, error) {
	size, err := storage.VerifyParts(ctx, s, upload, parts, s.maxBytes)
	if err != nil {
		return storage.Info{}, err
	}
	completed := make([]sdk.UploadPart, len(parts))
	for i, p := range parts {
		completed[i] = sdk.UploadPart{PartNumber: int32(p.Number), ETag: sdk.Ptr(p.ETag)}
	}
	_, err = s.client.CompleteMultipartUpload(ctx, &sdk.CompleteMultipartUploadRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID), CompleteMultipartUpload: &sdk.CompleteMultipartUpload{Parts: completed}})
	if err != nil {
		return storage.Info{}, err
	}
	return storage.Info{Key: upload.Key, Size: size, ModifiedAt: time.Now().UTC()}, nil
}
func (s *Store) AbortMultipart(ctx context.Context, upload storage.MultipartUpload) error {
	if err := storage.CheckMultipart(ctx, upload); err != nil {
		return err
	}
	_, err := s.client.AbortMultipartUpload(ctx, &sdk.AbortMultipartUploadRequest{Bucket: sdk.Ptr(s.bucket), Key: sdk.Ptr(upload.Key), UploadId: sdk.Ptr(upload.UploadID)})
	var serviceError *sdk.ServiceError
	if errors.As(err, &serviceError) && serviceError.Code == "NoSuchUpload" {
		return nil
	}
	return err
}

var _ storage.UploadPresigner = (*Store)(nil)
var _ storage.MultipartStore = (*Store)(nil)
var _ storage.PartPresigner = (*Store)(nil)