package file_server

import (
	"context"
	"errors"
	"fmt"
	"github.com/minio/minio-go/v7"
	"github.com/minio/minio-go/v7/pkg/credentials"
	"log"
	"path"
)

type MinioConfig struct {
	EndPoint  string `json:"endPoint"`
	AccessKey string `json:"accessKey"`
	SecretKey string `json:"secretKey"`
	UseSSL    bool   `json:"useSSL"`
}

func (c *MinioConfig) validate() error {
	if c.EndPoint == "" {
		return errors.New("EndPoint host not specified")
	}

	if c.AccessKey == "" {
		return errors.New("minio access key is not specified")
	}

	if c.SecretKey == "" {
		return errors.New("minio secret key is not specified")
	}
	return nil
}

func (c *MinioConfig) getClient() (*minio.Client, error) {
	if err := c.validate(); err != nil {
		return nil, err
	}

	minioClient, err := minio.New(
		c.EndPoint,
		&minio.Options{
			Creds:  credentials.NewStaticV4(c.AccessKey, c.SecretKey, ""),
			Secure: c.UseSSL,
		})

	if err != nil {
		log.Fatalf("connect minio server fail %s url %s", err.Error(), c.EndPoint)
		return nil, err
	}
	return minioClient, nil
}

type MinioServerOption func(*MinioServe)
type MinioServe struct {
	Client *minio.Client
}

func NewMinioServer(opts ...MinioServerOption) (*MinioServe, error) {
	m := &MinioServe{}
	for _, opt := range opts {
		opt(m)
	}
	return m, nil
}

func (m *MinioServe) Reset() {
	m.Client = nil
}

func (m *MinioServe) checkBucket(ctx context.Context, bucketName string) bool {
	isExist, err1 := m.Client.BucketExists(ctx, bucketName)
	if err1 != nil {
		log.Fatalf("checkBucket error " + err1.Error())
		return false
	}

	if !isExist {
		err2 := m.Client.MakeBucket(ctx, bucketName, minio.MakeBucketOptions{Region: defaultLocation})
		if err2 != nil {
			log.Fatalf("checkBucket error " + err2.Error())
			return false
		}
	}
	return true
}

func (m *MinioServe) checkBuckets(ctx context.Context) bool {
	b1 := m.checkBucket(ctx, defaultFileBucket)
	b2 := m.checkBucket(ctx, defaultIconBucket)
	return b1 && b2
}

func (m *MinioServe) uploadFile(objectName, filePath string) (*DestFile, error) {
	ctx := context.Background()
	bBucketExist := m.checkBuckets(ctx)
	if !bBucketExist {
		return nil, errors.New("bucket不存在")
	}

	contentType := "application/octet-stream"
	info, err := m.Client.FPutObject(ctx, defaultFileBucket, objectName, filePath, minio.PutObjectOptions{
		ContentType: contentType,
	})

	if err != nil {
		return nil, err
	}

	fileExt := path.Ext(objectName)
	url := fmt.Sprintf("http://%s/%s/%s", defaultConfig.EndPoint, defaultFileBucket, objectName)
	targetFile := &DestFile{
		FileName:     objectName,
		FileUrl:      url,
		FileSize:     info.Size,
		FileExt:      fileExt,
		FileMimeType: "",
	}

	return targetFile, nil
}