package service

import (
	"encoding/json"
	"fmt"
	"go_dreamfactory/cmd/v2/lib/common"
	"go_dreamfactory/cmd/v2/model"
	"log"
	"sync"
	"time"

	"github.com/boltdb/bolt"
	"github.com/sirupsen/logrus"
)

type DbService interface {
	Save(conf *model.GenTool) error
	Update() error
	Get() *model.GenTool
}

type DbServiceImpl struct {
}

var dbservice DbService

func NewDbService() DbService {
	dbservice = &DbServiceImpl{}
	return dbservice
}

func GetDbService() DbService {
	return dbservice
}

func (this *DbServiceImpl) Save(conf *model.GenTool) error {
	boltDb = GetBoltDb()
	defer boltDb.Close()
	_ = boltDb.Update(func(tx *bolt.Tx) error {
		b, err2 := json.Marshal(conf)
		if err2 != nil {
			return err
		}
		return bucket.Put([]byte(common.BUCKET_CONF), b)
	})
	return nil
}

func (this *DbServiceImpl) Get() *model.GenTool {
	boltDb = GetBoltDb()
	defer boltDb.Close()
	conf := &model.GenTool{}
	if err := boltDb.View(func(tx *bolt.Tx) error {
		c := tx.Bucket([]byte(common.BOLTDB_BUCKETNAME))
		if c == nil {
			return fmt.Errorf("Bucket %s not found!", common.BOLTDB_BUCKETNAME)
		}

		val := c.Get([]byte(common.BUCKET_CONF))
		if err := json.Unmarshal(val, conf); err != nil {
			logrus.Errorf("get gen conf err:%v", err)
			return err
		}
		return nil
	}); err != nil {
		logrus.Errorf("get db conf err: %v", err)
		return nil
	}
	return conf
}

func (this *DbServiceImpl) Update() error {
	return nil
}

var (
	boltDb *bolt.DB
	bucket *bolt.Bucket
	once   sync.Once
	err    error
)

func GetBoltDb() *bolt.DB {
	once.Do(func() {
		boltDb, err = bolt.Open(common.BOLTDB_NAME, 0600, &bolt.Options{Timeout: 1 * time.Second})
		if err != nil {
			log.Fatal(err)
		}

		boltDb.Update(func(tx *bolt.Tx) error {
			b := tx.Bucket([]byte(common.BOLTDB_BUCKETNAME))
			if b != nil {
				bucket = b
			} else {
				bucket, err = tx.CreateBucket([]byte(common.BOLTDB_BUCKETNAME))
				if err != nil {
					return fmt.Errorf("create bucket: %s", err)
				}
			}
			return nil
		})
	})
	return boltDb
}