package loader

import (
	"context"
	"fmt"
	"path/filepath"
	"strings"

	"git.kapelle.org/niklas/s3browser/internal/cache"
	"git.kapelle.org/niklas/s3browser/internal/helper"
	types "git.kapelle.org/niklas/s3browser/internal/types"
	"github.com/graph-gophers/dataloader"
	"github.com/minio/minio-go/v7"
	log "github.com/sirupsen/logrus"
)

type Loader struct {
	listObjectsLoader          *dataloader.Loader
	listObjectsRecursiveLoader *dataloader.Loader
	statObjectLoader           *dataloader.Loader
	listBucketsLoader          *dataloader.Loader
}

func NewLoader(config types.AppConfig) *Loader {
	return &Loader{
		listObjectsLoader: dataloader.NewBatchedLoader(
			listObjectsBatch,
			dataloader.WithCache(cache.NewTTLCache(config.CacheTTL, config.CacheCleanup)),
		),
		listObjectsRecursiveLoader: dataloader.NewBatchedLoader(
			listObjectsRecursiveBatch,
			dataloader.WithCache(cache.NewTTLCache(config.CacheTTL, config.CacheCleanup)),
		),
		statObjectLoader: dataloader.NewBatchedLoader(
			statObjectBatch,
			dataloader.WithCache(cache.NewTTLCache(config.CacheTTL, config.CacheCleanup)),
		),
		listBucketsLoader: dataloader.NewBatchedLoader(
			listBucketsBatch,
			dataloader.WithCache(cache.NewTTLCache(config.CacheTTL, config.CacheCleanup)),
		),
	}
}

func (l *Loader) GetFiles(ctx context.Context, path types.ID) ([]types.File, error) {
	thunk := l.listObjectsLoader.Load(ctx, path)
	objects, err := thunk()

	if err != nil {
		return nil, err
	}

	var files []types.File

	for _, obj := range objects.([]minio.ObjectInfo) {
		if obj.Err != nil {
			return nil, obj.Err
		} else if !strings.HasSuffix(obj.Key, "/") {
			files = append(files, *helper.ObjInfoToFile(obj, path.Bucket))
		}
	}

	return files, nil
}

func (l *Loader) GetFile(ctx context.Context, id types.ID) (*types.File, error) {
	thunk := l.statObjectLoader.Load(ctx, id)

	result, err := thunk()
	if err != nil {
		return nil, err
	}
	objInfo, ok := result.(minio.ObjectInfo)

	if !ok {
		return nil, fmt.Errorf("Failed to stats object")
	}

	return helper.ObjInfoToFile(objInfo, id.Bucket), nil
}

func (l *Loader) GetDirs(ctx context.Context, path types.ID) ([]types.Directory, error) {
	thunk := l.listObjectsLoader.Load(ctx, path)

	result, err := thunk()
	if err != nil {
		return nil, err
	}

	var dirs []types.Directory
	for _, obj := range result.([]minio.ObjectInfo) {
		if obj.Err != nil {
			return nil, obj.Err
		} else if strings.HasSuffix(obj.Key, "/") {
			resultID := types.ID{
				Bucket: path.Bucket,
				Key:    obj.Key,
			}

			resultID.Normalize()

			dirs = append(dirs, types.Directory{
				ID:   resultID,
				Name: filepath.Base(obj.Key),
			})
		}
	}

	return dirs, nil
}

func (l *Loader) GetBuckets(ctx context.Context) ([]string, error) {
	thunk := l.listBucketsLoader.Load(ctx, dataloader.StringKey(""))

	result, err := thunk()

	if err != nil {
		return nil, err
	}

	bucketsInfo := result.([]minio.BucketInfo)
	var buckets []string
	for _, i := range bucketsInfo {
		buckets = append(buckets, i.Name)
	}

	return buckets, nil
}

func (l *Loader) GetFilesRecursive(ctx context.Context, path types.ID) ([]types.File, error) {
	thunk := l.listObjectsRecursiveLoader.Load(ctx, path)
	result, err := thunk()

	if err != nil {
		return nil, err
	}

	objects := result.([]minio.ObjectInfo)

	var files []types.File
	for _, obj := range objects {
		files = append(files, *helper.ObjInfoToFile(obj, path.Bucket))
	}

	return files, nil
}

func (l *Loader) InvalidateCacheForFile(ctx context.Context, id types.ID) {
	log.Debug("Clear cache for file:", id.String())
	parent := id.Parent()

	l.listObjectsLoader.Clear(ctx, id)
	l.listObjectsRecursiveLoader.Clear(ctx, parent)
}

func (l *Loader) InvalidateCacheForDir(ctx context.Context, path types.ID) {
	log.Debug("Clear cache for dir:", path.String())
	parent := helper.GetParentDir(path)

	l.listBucketsLoader.Clear(ctx, path).Clear(ctx, parent)
	l.listObjectsRecursiveLoader.Clear(ctx, path).Clear(ctx, parent)
}