package dal

import (
	"context"
	"fmt"
	"github.com/minio/minio-go/v7"
	"io"
	"sync"
)

const (
	bucketImages  = "squizimages"
	bucketFonts   = "squizfonts"
	bucketScripts = "squizscript"
	bucketStyle   = "squizstyle"
)

type Storer struct {
	client *minio.Client
}

func New(ctx context.Context, minioClient *minio.Client) (*Storer, error) {
	if ok, err := minioClient.BucketExists(ctx, bucketImages); !ok {
		if err := minioClient.MakeBucket(ctx, bucketImages, minio.MakeBucketOptions{}); err != nil {
			return nil, err
		}
	} else if err != nil {
		return nil, err
	}

	if ok, err := minioClient.BucketExists(ctx, bucketFonts); !ok {
		if err := minioClient.MakeBucket(ctx, bucketFonts, minio.MakeBucketOptions{}); err != nil {
			return nil, err
		}
	} else if err != nil {
		return nil, err
	}

	if ok, err := minioClient.BucketExists(ctx, bucketScripts); !ok {
		if err := minioClient.MakeBucket(ctx, bucketScripts, minio.MakeBucketOptions{}); err != nil {
			return nil, err
		}
	} else if err != nil {
		return nil, err
	}

	if ok, err := minioClient.BucketExists(ctx, bucketStyle); !ok {
		if err := minioClient.MakeBucket(ctx, bucketStyle, minio.MakeBucketOptions{}); err != nil {
			return nil, err
		}
	} else if err != nil {
		return nil, err
	}

	return &Storer{
		client: minioClient,
	}, nil
}

func (s *Storer) UploadImages(ctx context.Context, quid string, files map[string]io.Reader, sizes map[string]int64) []error {
	var (
		wg   sync.WaitGroup
		m    sync.Mutex
		errs []error
	)
	wg.Add(len(files))
	for f, r := range files {
		fname := f
		reader := r
		go func() {
			defer wg.Done()
			_, err := s.client.PutObject(ctx,
				bucketImages,
				fmt.Sprintf("%s/%s", quid, fname),
				reader,
				sizes[fname],
				minio.PutObjectOptions{})
			if err != nil {
				m.Lock()
				defer m.Unlock()
				errs = append(errs, err)
			}
		}()
	}
	wg.Wait()

	return errs
}

func (s *Storer) UploadFonts(ctx context.Context, quid string, files map[string]io.Reader, sizes map[string]int64) []error {
	var (
		wg   sync.WaitGroup
		m    sync.Mutex
		errs []error
	)
	wg.Add(len(files))
	for f, r := range files {
		fname := f
		reader := r
		go func() {
			defer wg.Done()
			if _, err := s.client.PutObject(ctx,
				bucketFonts,
				fmt.Sprintf("%s/%s", quid, fname),
				reader,
				sizes[fname],
				minio.PutObjectOptions{}); err != nil {

				m.Lock()
				defer m.Unlock()
				errs = append(errs, err)
			}
		}()
	}
	wg.Wait()

	return errs
}

func (s *Storer) UploadScript(ctx context.Context, quid string, file io.Reader, size int64) error {
	if _, err := s.client.PutObject(ctx,
		bucketScripts,
		fmt.Sprintf("%s.js", quid),
		file,
		size,
		minio.PutObjectOptions{}); err != nil {
		return err
	}

	return nil
}

func (s *Storer) UploadStyle(ctx context.Context, quid string, file io.Reader, size int64) error {
	if _, err := s.client.PutObject(ctx,
		bucketStyle,
		fmt.Sprintf("%s.css", quid),
		file,
		size,
		minio.PutObjectOptions{}); err != nil {
		return err
	}

	return nil
}