package writecache

import (
	"context"
	"os"
	"sync"

	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/blobstor/fstree"
	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/local_object_storage/shard/mode"
	"git.frostfs.info/TrueCloudLab/frostfs-node/pkg/util/logger"
	"git.frostfs.info/TrueCloudLab/frostfs-sdk-go/object"
	"go.etcd.io/bbolt"
	"go.uber.org/zap"
)

// Info groups the information about write-cache.
type Info struct {
	// Full path to the write-cache.
	Path string
}

// Cache represents write-cache for objects.
type Cache struct {
	options

	// objCounters contains atomic counters for the number of objects stored in cache.
	objCounters counters

	modeMtx sync.RWMutex
	mode    mode.Mode

	// flushCh is a channel with objects to flush.
	smallFlushCh chan objWithData
	// workersChan is close channel, protected by modeMtx.
	// It indicates status of the background workers.
	workersChan chan struct{}
	// wg is a wait group for flush workers.
	wg sync.WaitGroup
	// store contains underlying database.
	smallStore
	// fsTree contains big files stored directly on file-system.
	fsTree *fstree.FSTree
}

// wcStorageType is used for write-cache operations logging.
const wcStorageType = "write-cache"

type objectInfo struct {
	addr string
	data []byte
	obj  *object.Object
}

const (
	defaultMaxObjectSize   = 64 * 1024 * 1024 // 64 MiB
	defaultSmallObjectSize = 32 * 1024        // 32 KiB
	defaultMaxCacheSize    = 1 << 30          // 1 GiB
)

var (
	defaultBucket = []byte{0}
)

// New creates new writecache instance.
// The value must not be copied after creation.
func New(opts ...Option) *Cache {
	closeCh := make(chan struct{})
	close(closeCh)

	c := &Cache{
		smallFlushCh: make(chan objWithData),
		mode:         mode.ReadWrite,
		workersChan:  closeCh,

		options: options{
			log:             &logger.Logger{Logger: zap.NewNop()},
			maxObjectSize:   defaultMaxObjectSize,
			smallObjectSize: defaultSmallObjectSize,
			workersCount:    defaultFlushWorkersCount,
			maxCacheSize:    defaultMaxCacheSize,
			maxBatchSize:    bbolt.DefaultMaxBatchSize,
			maxBatchDelay:   bbolt.DefaultMaxBatchDelay,
			openFile:        os.OpenFile,
		},
	}

	for i := range opts {
		opts[i](&c.options)
	}

	return c
}

// SetLogger sets logger. It is used after the shard ID was generated to use it in logs.
func (c *Cache) SetLogger(l *logger.Logger) {
	c.log = l
}

func (c *Cache) DumpInfo() Info {
	return Info{
		Path: c.path,
	}
}

// Open opens and initializes database. Reads object counters from the ObjectCounters instance.
func (c *Cache) Open(readOnly bool) error {
	err := c.openStore(readOnly)
	if err != nil {
		return err
	}

	c.modeMtx.Lock()
	defer c.modeMtx.Unlock()

	if readOnly {
		c.mode = mode.ReadOnly
	} else {
		c.mode = mode.ReadWrite
	}

	return nil
}

// Close closes db connection and stops services. Executes ObjectCounters.FlushAndClose op.
func (c *Cache) Close() error {
	// Finish all in-progress operations if they are
	// in progress.
	select {
	case <-c.workersChan:
	default:
		err := c.setMode(context.TODO(), mode.ReadOnly)
		if err != nil {
			return err
		}
	}

	var err error
	if c.db != nil {
		err = c.db.Close()
		if err != nil {
			c.db = nil
		}
	}
	return nil
}