package auth

import (
	"context"
	"crypto"
	"crypto/hmac"
	"crypto/rand"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"io"
	"mime/multipart"
	"net/http"
	"net/url"
	"regexp"
	"strings"
	"time"

	v4a "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/auth/signer/v4asdk2"
	v4 "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/auth/signer/v4sdk2/signer/v4"
	apierr "git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/errors"
	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/api/middleware"
	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/creds/accessbox"
	"git.frostfs.info/TrueCloudLab/frostfs-s3-gw/creds/tokens"
	cid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/container/id"
	oid "git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object/id"
	"github.com/aws/aws-sdk-go-v2/aws"
	"github.com/aws/aws-sdk-go-v2/credentials"
)

var (
	// AuthorizationFieldRegexp -- is regexp for credentials with Base58 encoded cid and oid and '0' (zero) as delimiter.
	AuthorizationFieldRegexp = regexp.MustCompile(`AWS4-HMAC-SHA256 Credential=(?P<access_key_id>[^/]+)/(?P<date>[^/]+)/(?P<region>[^/]*)/(?P<service>[^/]+)/aws4_request,\s*SignedHeaders=(?P<signed_header_fields>.+),\s*Signature=(?P<v4_signature>.+)`)

	// authorizationFieldV4aRegexp -- is regexp for credentials with Base58 encoded cid and oid and '0' (zero) as delimiter.
	authorizationFieldV4aRegexp = regexp.MustCompile(`AWS4-ECDSA-P256-SHA256 Credential=(?P<access_key_id>[^/]+)/(?P<date>[^/]+)/(?P<service>[^/]+)/aws4_request,\s*SignedHeaders=(?P<signed_header_fields>.+),\s*Signature=(?P<v4_signature>.+)`)

	// postPolicyCredentialRegexp -- is regexp for credentials when uploading file using POST with policy.
	postPolicyCredentialRegexp = regexp.MustCompile(`(?P<access_key_id>[^/]+)/(?P<date>[^/]+)/(?P<region>[^/]*)/(?P<service>[^/]+)/aws4_request`)
)

type (
	Center struct {
		reg                        *RegexpSubmatcher
		regV4a                     *RegexpSubmatcher
		postReg                    *RegexpSubmatcher
		cli                        tokens.Credentials
		allowedAccessKeyIDPrefixes []string // empty slice means all access key ids are allowed
		settings                   CenterSettings
	}

	CenterSettings interface {
		AccessBoxContainer() (cid.ID, bool)
	}

	//nolint:revive
	AuthHeader struct {
		AccessKeyID  string
		Service      string
		Region       string
		Signature    string
		SignedFields []string
		Date         string
		IsPresigned  bool
		Expiration   time.Duration
		Preamble     string
		PayloadHash  string
	}
)

const (
	authHeaderPartsNum    = 6
	authHeaderV4aPartsNum = 5
	maxFormSizeMemory     = 50 * 1048576 // 50 MB

	AmzAlgorithm     = "X-Amz-Algorithm"
	AmzCredential    = "X-Amz-Credential"
	AmzSignature     = "X-Amz-Signature"
	AmzSignedHeaders = "X-Amz-SignedHeaders"
	AmzRegionSet     = "X-Amz-Region-Set"
	AmzExpires       = "X-Amz-Expires"
	AmzDate          = "X-Amz-Date"
	AmzContentSHA256 = "X-Amz-Content-Sha256"
	AuthorizationHdr = "Authorization"
	ContentTypeHdr   = "Content-Type"

	UnsignedPayload                    = "UNSIGNED-PAYLOAD"
	StreamingUnsignedPayloadTrailer    = "STREAMING-UNSIGNED-PAYLOAD-TRAILER"
	StreamingContentSHA256             = "STREAMING-AWS4-HMAC-SHA256-PAYLOAD"
	StreamingContentSHA256Trailer      = "STREAMING-AWS4-HMAC-SHA256-PAYLOAD-TRAILER"
	StreamingContentECDSASHA256        = "STREAMING-AWS4-ECDSA-P256-SHA256-PAYLOAD"
	StreamingContentECDSASHA256Trailer = "STREAMING-AWS4-ECDSA-P256-SHA256-PAYLOAD-TRAILER"
)

var ContentSHA256HeaderStandardValue = map[string]struct{}{
	UnsignedPayload:                    {},
	StreamingUnsignedPayloadTrailer:    {},
	StreamingContentSHA256:             {},
	StreamingContentSHA256Trailer:      {},
	StreamingContentECDSASHA256:        {},
	StreamingContentECDSASHA256Trailer: {},
}

// New creates an instance of AuthCenter.
func New(creds tokens.Credentials, prefixes []string, settings CenterSettings) *Center {
	return &Center{
		cli:                        creds,
		reg:                        NewRegexpMatcher(AuthorizationFieldRegexp),
		regV4a:                     NewRegexpMatcher(authorizationFieldV4aRegexp),
		postReg:                    NewRegexpMatcher(postPolicyCredentialRegexp),
		allowedAccessKeyIDPrefixes: prefixes,
		settings:                   settings,
	}
}

const (
	signaturePreambleSigV4  = "AWS4-HMAC-SHA256"
	signaturePreambleSigV4A = "AWS4-ECDSA-P256-SHA256"
)

func (c *Center) parseAuthHeader(authHeader string, headers http.Header) (*AuthHeader, error) {
	preamble, _, _ := strings.Cut(authHeader, " ")

	var (
		submatches map[string]string
		region     string
	)

	switch preamble {
	case signaturePreambleSigV4:
		submatches = c.reg.GetSubmatches(authHeader)
		if len(submatches) != authHeaderPartsNum {
			return nil, fmt.Errorf("%w: %s", apierr.GetAPIError(apierr.ErrAuthorizationHeaderMalformed), authHeader)
		}
		region = submatches["region"]
	case signaturePreambleSigV4A:
		submatches = c.regV4a.GetSubmatches(authHeader)
		if len(submatches) != authHeaderV4aPartsNum {
			return nil, fmt.Errorf("%w: %s", apierr.GetAPIError(apierr.ErrAuthorizationHeaderMalformed), authHeader)
		}
		region = headers.Get(AmzRegionSet)
	default:
		return nil, fmt.Errorf("%w: %s", apierr.GetAPIError(apierr.ErrAuthorizationHeaderMalformed), authHeader)
	}
	// AWS4-ECDSA-P256-SHA256
	// Credential=2XGRML5EW3LMHdf64W2DkBy1Nkuu4y4wGhUj44QjbXBi05ZNvs8WVwy1XTmSEkcVkydPKzCgtmR7U3zyLYTj3Snxf/20240326/s3/aws4_request,
	// SignedHeaders=amz-sdk-invocation-id;amz-sdk-request;host;x-amz-content-sha256;x-amz-date;x-amz-region-set,
	// Signature=3044022006a2bc760140834101d0a79667d6aa75768c1a28e9cafc8963484d0752a6c6050220629dc06d7d6505e1b1e2a5d1f974b25ba32fdffc6f3f70dc4dda31b8a6f7ea2b

	return &AuthHeader{
		AccessKeyID:  submatches["access_key_id"],
		Service:      submatches["service"],
		Region:       region,
		Signature:    submatches["v4_signature"],
		SignedFields: strings.Split(submatches["signed_header_fields"], ";"),
		Date:         submatches["date"],
		Preamble:     preamble,
		PayloadHash:  headers.Get(AmzContentSHA256),
	}, nil
}

func IsStandardContentSHA256(key string) bool {
	_, ok := ContentSHA256HeaderStandardValue[key]
	return ok
}

func (c *Center) Authenticate(r *http.Request) (*middleware.Box, error) {
	var (
		err                  error
		authHdr              *AuthHeader
		signatureDateTimeStr string
		needClientTime       bool
	)

	queryValues := r.URL.Query()
	if queryValues.Get(AmzAlgorithm) == signaturePreambleSigV4 {
		creds := strings.Split(queryValues.Get(AmzCredential), "/")
		if len(creds) != 5 || creds[4] != "aws4_request" {
			return nil, fmt.Errorf("bad X-Amz-Credential")
		}
		authHdr = &AuthHeader{
			AccessKeyID:  creds[0],
			Service:      creds[3],
			Region:       creds[2],
			Signature:    queryValues.Get(AmzSignature),
			SignedFields: strings.Split(queryValues.Get(AmzSignedHeaders), ";"),
			Date:         creds[1],
			IsPresigned:  true,
			Preamble:     signaturePreambleSigV4,
			PayloadHash:  r.Header.Get(AmzContentSHA256),
		}
		authHdr.Expiration, err = time.ParseDuration(queryValues.Get(AmzExpires) + "s")
		if err != nil {
			return nil, fmt.Errorf("%w: couldn't parse X-Amz-Expires %v", apierr.GetAPIError(apierr.ErrMalformedExpires), err)
		}
		signatureDateTimeStr = queryValues.Get(AmzDate)
	} else if queryValues.Get(AmzAlgorithm) == signaturePreambleSigV4A {
		creds := strings.Split(queryValues.Get(AmzCredential), "/")
		if len(creds) != 4 || creds[3] != "aws4_request" {
			return nil, fmt.Errorf("bad X-Amz-Credential")
		}
		authHdr = &AuthHeader{
			AccessKeyID:  creds[0],
			Service:      creds[2],
			Region:       queryValues.Get(AmzRegionSet),
			Signature:    queryValues.Get(AmzSignature),
			SignedFields: strings.Split(queryValues.Get(AmzSignedHeaders), ";"),
			Date:         creds[1],
			IsPresigned:  true,
			Preamble:     signaturePreambleSigV4A,
			PayloadHash:  r.Header.Get(AmzContentSHA256),
		}
		authHdr.Expiration, err = time.ParseDuration(queryValues.Get(AmzExpires) + "s")
		if err != nil {
			return nil, fmt.Errorf("%w: couldn't parse X-Amz-Expires %v", apierr.GetAPIError(apierr.ErrMalformedExpires), err)
		}
		signatureDateTimeStr = queryValues.Get(AmzDate)
	} else {
		authHeaderField := r.Header[AuthorizationHdr]
		if len(authHeaderField) != 1 {
			if strings.HasPrefix(r.Header.Get(ContentTypeHdr), "multipart/form-data") {
				return c.checkFormData(r)
			}
			return nil, fmt.Errorf("%w: %v", middleware.ErrNoAuthorizationHeader, authHeaderField)
		}
		authHdr, err = c.parseAuthHeader(authHeaderField[0], r.Header)
		if err != nil {
			return nil, err
		}
		signatureDateTimeStr = r.Header.Get(AmzDate)
		needClientTime = true
	}

	signatureDateTime, err := time.Parse("20060102T150405Z", signatureDateTimeStr)
	if err != nil {
		return nil, fmt.Errorf("failed to parse x-amz-date header field: %w", err)
	}

	if err = c.checkAccessKeyID(authHdr.AccessKeyID); err != nil {
		return nil, err
	}

	cnrID, err := c.getAccessBoxContainer(authHdr.AccessKeyID)
	if err != nil {
		return nil, err
	}

	box, attrs, err := c.cli.GetBox(r.Context(), cnrID, authHdr.AccessKeyID)
	if err != nil {
		return nil, fmt.Errorf("get box by access key '%s': %w", authHdr.AccessKeyID, err)
	}

	if err = checkFormatHashContentSHA256(r.Header.Get(AmzContentSHA256)); err != nil {
		return nil, err
	}

	clonedRequest := cloneRequest(r, authHdr)
	if err = c.checkSign(r.Context(), authHdr, box, clonedRequest, signatureDateTime); err != nil {
		return nil, err
	}

	result := &middleware.Box{
		AccessBox: box,
		AuthHeaders: &middleware.AuthHeader{
			AccessKeyID: authHdr.AccessKeyID,
			Region:      authHdr.Region,
			SignatureV4: authHdr.Signature,
		},
		Attributes: attrs,
	}
	if needClientTime {
		result.ClientTime = signatureDateTime
	}

	return result, nil
}

func (c *Center) getAccessBoxContainer(accessKeyID string) (cid.ID, error) {
	var addr oid.Address
	if err := addr.DecodeString(strings.ReplaceAll(accessKeyID, "0", "/")); err == nil {
		return addr.Container(), nil
	}

	cnrID, ok := c.settings.AccessBoxContainer()
	if ok {
		return cnrID, nil
	}

	return cid.ID{}, fmt.Errorf("%w: unknown container for creds '%s'", apierr.GetAPIError(apierr.ErrInvalidAccessKeyID), accessKeyID)
}

func checkFormatHashContentSHA256(hash string) error {
	if !IsStandardContentSHA256(hash) {
		hashBinary, err := hex.DecodeString(hash)
		if err != nil {
			return fmt.Errorf("%w: decode hash: %s: %s", apierr.GetAPIError(apierr.ErrContentSHA256Mismatch),
				hash, err.Error())
		}
		if len(hashBinary) != sha256.Size && len(hash) != 0 {
			return fmt.Errorf("%w: invalid hash size %d", apierr.GetAPIError(apierr.ErrContentSHA256Mismatch), len(hashBinary))
		}
	}

	return nil
}

func (c Center) checkAccessKeyID(accessKeyID string) error {
	if len(c.allowedAccessKeyIDPrefixes) == 0 {
		return nil
	}

	for _, prefix := range c.allowedAccessKeyIDPrefixes {
		if strings.HasPrefix(accessKeyID, prefix) {
			return nil
		}
	}

	return fmt.Errorf("%w: accesskeyID prefix isn't allowed", apierr.GetAPIError(apierr.ErrAccessDenied))
}

func (c *Center) checkFormData(r *http.Request) (*middleware.Box, error) {
	if err := r.ParseMultipartForm(maxFormSizeMemory); err != nil {
		return nil, fmt.Errorf("%w: parse multipart form with max size %d", apierr.GetAPIError(apierr.ErrInvalidArgument), maxFormSizeMemory)
	}

	if err := prepareForm(r.MultipartForm); err != nil {
		return nil, fmt.Errorf("couldn't parse form: %w", err)
	}

	policy := MultipartFormValue(r, "policy")
	if policy == "" {
		return nil, fmt.Errorf("%w: missing policy", middleware.ErrNoAuthorizationHeader)
	}

	creds := MultipartFormValue(r, "x-amz-credential")
	submatches := c.postReg.GetSubmatches(creds)
	if len(submatches) != 4 {
		return nil, fmt.Errorf("%w: %s", apierr.GetAPIError(apierr.ErrAuthorizationHeaderMalformed), creds)
	}

	signatureDateTime, err := time.Parse("20060102T150405Z", MultipartFormValue(r, "x-amz-date"))
	if err != nil {
		return nil, fmt.Errorf("failed to parse x-amz-date field: %w", err)
	}

	accessKeyID := submatches["access_key_id"]

	cnrID, err := c.getAccessBoxContainer(accessKeyID)
	if err != nil {
		return nil, err
	}

	box, attrs, err := c.cli.GetBox(r.Context(), cnrID, accessKeyID)
	if err != nil {
		return nil, fmt.Errorf("get box by accessKeyID '%s': %w", accessKeyID, err)
	}

	secret := box.Gate.SecretKey
	service, region := submatches["service"], submatches["region"]

	signature := SignStr(secret, service, region, signatureDateTime, policy)
	reqSignature := MultipartFormValue(r, "x-amz-signature")
	if signature != reqSignature {
		return nil, fmt.Errorf("%w: %s != %s", apierr.GetAPIError(apierr.ErrSignatureDoesNotMatch),
			reqSignature, signature)
	}

	return &middleware.Box{
		AccessBox: box,
		AuthHeaders: &middleware.AuthHeader{
			AccessKeyID: accessKeyID,
			Region:      region,
			SignatureV4: signature,
		},
		Attributes: attrs,
	}, nil
}

func cloneRequest(r *http.Request, authHeader *AuthHeader) *http.Request {
	otherRequest := r.Clone(context.TODO())
	otherRequest.Header = make(http.Header)

	for key, val := range r.Header {
		for _, name := range authHeader.SignedFields {
			if strings.EqualFold(key, name) {
				otherRequest.Header[key] = val
			}
		}
	}

	if authHeader.IsPresigned {
		otherQuery := otherRequest.URL.Query()
		otherQuery.Del(AmzSignature)
		otherRequest.URL.RawQuery = otherQuery.Encode()
	}

	return otherRequest
}

func (c *Center) checkSign(ctx context.Context, authHeader *AuthHeader, box *accessbox.Box, request *http.Request, signatureDateTime time.Time) error {
	var signature string

	switch authHeader.Preamble {
	case signaturePreambleSigV4:
		creds := aws.Credentials{
			AccessKeyID:     authHeader.AccessKeyID,
			SecretAccessKey: box.Gate.SecretKey,
		}
		signer := v4.NewSigner(func(options *v4.SignerOptions) {
			options.DisableURIPathEscaping = true
		})

		if authHeader.IsPresigned {
			if err := checkPresignedDate(authHeader, signatureDateTime); err != nil {
				return err
			}

			signedURI, _, err := signer.PresignHTTP(ctx, creds, request, authHeader.PayloadHash, authHeader.Service, authHeader.Region, signatureDateTime)
			if err != nil {
				return fmt.Errorf("failed to pre-sign temporary HTTP request: %w", err)
			}

			u, err := url.ParseRequestURI(signedURI)
			if err != nil {
				return err
			}
			signature = u.Query().Get(AmzSignature)
		} else {
			if err := signer.SignHTTP(ctx, creds, request, authHeader.PayloadHash, authHeader.Service, authHeader.Region, signatureDateTime); err != nil {
				return fmt.Errorf("failed to sign temporary HTTP request: %w", err)
			}
			signature = c.reg.GetSubmatches(request.Header.Get(AuthorizationHdr))["v4_signature"]
		}
		if authHeader.Signature != signature {
			return fmt.Errorf("%w: %s != %s: headers %v", apierr.GetAPIError(apierr.ErrSignatureDoesNotMatch),
				authHeader.Signature, signature, authHeader.SignedFields)
		}

	case signaturePreambleSigV4A:
		signer := v4a.NewSigner(func(options *v4a.SignerOptions) {
			options.DisableURIPathEscaping = true
		})

		credAdapter := v4a.SymmetricCredentialAdaptor{
			SymmetricProvider: credentials.NewStaticCredentialsProvider(authHeader.AccessKeyID, box.Gate.SecretKey, ""),
		}

		creds, err := credAdapter.RetrievePrivateKey(request.Context())
		if err != nil {
			return fmt.Errorf("failed to derive assymetric key from credentials: %w", err)
		}

		if !authHeader.IsPresigned {
			return signer.VerifySignature(creds, request, authHeader.PayloadHash, authHeader.Service,
				strings.Split(authHeader.Region, ","), signatureDateTime, authHeader.Signature)
		}

		if err = checkPresignedDate(authHeader, signatureDateTime); err != nil {
			return err
		}

		return signer.VerifyPresigned(creds, request, authHeader.PayloadHash, authHeader.Service,
			strings.Split(authHeader.Region, ","), signatureDateTime, authHeader.Signature)
	default:
		return fmt.Errorf("invalid preamble: %s", authHeader.Preamble)
	}

	return nil
}

func checkPresignedDate(authHeader *AuthHeader, signatureDateTime time.Time) error {
	now := time.Now()
	if signatureDateTime.Add(authHeader.Expiration).Before(now) {
		return fmt.Errorf("%w: expired: now %s, signature %s", apierr.GetAPIError(apierr.ErrExpiredPresignRequest),
			now.Format(time.RFC3339), signatureDateTime.Format(time.RFC3339))
	}
	if now.Before(signatureDateTime) {
		return fmt.Errorf("%w: signature time from the future: now %s, signature %s", apierr.GetAPIError(apierr.ErrBadRequest),
			now.Format(time.RFC3339), signatureDateTime.Format(time.RFC3339))
	}
	return nil
}

func SignStr(secret, service, region string, t time.Time, strToSign string) string {
	creds := deriveKey(secret, service, region, t)
	signature := hmacSHA256(creds, []byte(strToSign))
	return hex.EncodeToString(signature)
}

func SignStrV4A(cred aws.Credentials, strToSign string) (string, error) {
	hash := sha256.New()
	hash.Write([]byte(strToSign))

	credAdapter := v4a.SymmetricCredentialAdaptor{
		SymmetricProvider: credentials.NewStaticCredentialsProvider(cred.AccessKeyID, cred.SecretAccessKey, ""),
	}

	creds, err := credAdapter.RetrievePrivateKey(context.Background()) // because of using StaticCredentialsProvider
	if err != nil {
		// no error is expected
		panic(err)
	}

	sig, err := creds.PrivateKey.Sign(rand.Reader, hash.Sum(nil), crypto.SHA256)
	if err != nil {
		return "", err
	}

	return hex.EncodeToString(sig), nil
}

func deriveKey(secret, service, region string, t time.Time) []byte {
	hmacDate := hmacSHA256([]byte("AWS4"+secret), []byte(t.UTC().Format("20060102")))
	hmacRegion := hmacSHA256(hmacDate, []byte(region))
	hmacService := hmacSHA256(hmacRegion, []byte(service))
	return hmacSHA256(hmacService, []byte("aws4_request"))
}

func hmacSHA256(key []byte, data []byte) []byte {
	hash := hmac.New(sha256.New, key)
	hash.Write(data)
	return hash.Sum(nil)
}

// MultipartFormValue gets value by key from multipart form.
func MultipartFormValue(r *http.Request, key string) string {
	if r.MultipartForm == nil {
		return ""
	}
	if vs := r.MultipartForm.Value[key]; len(vs) > 0 {
		return vs[0]
	}

	return ""
}

func prepareForm(form *multipart.Form) error {
	var oldKeysValue []string
	var oldKeysFile []string

	for k, v := range form.Value {
		lowerKey := strings.ToLower(k)
		if lowerKey != k {
			form.Value[lowerKey] = v
			oldKeysValue = append(oldKeysValue, k)
		}
	}
	for _, k := range oldKeysValue {
		delete(form.Value, k)
	}

	for k, v := range form.File {
		lowerKey := strings.ToLower(k)
		if lowerKey != "file" {
			oldKeysFile = append(oldKeysFile, k)
			if len(v) > 0 {
				field, err := v[0].Open()
				if err != nil {
					return fmt.Errorf("file header open: %w", err)
				}

				data, err := io.ReadAll(field)
				if err != nil {
					return fmt.Errorf("read field: %w", err)
				}
				form.Value[lowerKey] = []string{string(data)}
			}
		} else if lowerKey != k {
			form.File[lowerKey] = v
			oldKeysFile = append(oldKeysFile, k)
		}
	}
	for _, k := range oldKeysFile {
		delete(form.File, k)
	}

	return nil
}