package boltdb

import (
	"encoding/json"

	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"
	"github.com/boltdb/bolt"
)

//InitDB - To create database and bucket
func InitDB(boltDatabasePath, bucketName string) (*bolt.DB, error) {
	db, err := bolt.Open(boltDatabasePath, 0777, nil)
	if errormdl.CheckErr(err) != nil {
		return nil, errormdl.CheckErr(err)
	}
	err = db.Update(func(tx *bolt.Tx) error {
		_, bktErr := tx.CreateBucketIfNotExists([]byte(bucketName))
		if errormdl.CheckErr1(bktErr) != nil {
			return errormdl.CheckErr1(bktErr)
		}
		return nil
	})
	if errormdl.CheckErr2(err) != nil {
		return nil, errormdl.Wrap("ERROR: Could not set up bucket " + bucketName)
	}
	return db, nil
}

// AddKey - To add key into bucket
func AddKey(db *bolt.DB, bucket string, key string, val string) error {
	if db != nil {
		return db.Update(func(tx *bolt.Tx) error {
			_, bktErr := tx.CreateBucketIfNotExists([]byte(bucket))
			if errormdl.CheckErr(bktErr) != nil {
				return errormdl.CheckErr(bktErr)
			}
			return tx.Bucket([]byte(bucket)).Put([]byte(key), []byte(val))
		})
	}
	return errormdl.Wrap("ERROR: Could not Add key in nil db instance")
}

// RemoveKey - To remove key from bucket
func RemoveKey(db *bolt.DB, bucket, key string) error {
	if db != nil {
		return db.Update(func(tx *bolt.Tx) error {
			bkt := tx.Bucket([]byte(bucket))
			if bkt == nil {
				return errormdl.Wrap("Bucket not found: " + bucket)
			}
			return bkt.Delete([]byte(key))
		})
	}
	return errormdl.Wrap("ERROR: Could not Delete key in nil db instance")
}

// GetKey - To get data in bucket of given key
func GetKey(db *bolt.DB, bucket, key string) ([]byte, error) {
	if db != nil {
		var byteData []byte
		err := db.View(func(tx *bolt.Tx) error {
			bkt := tx.Bucket([]byte(bucket))
			if bkt == nil {
				return errormdl.Wrap("Bucket not found: " + bucket)
			}
			byteData = bkt.Get([]byte(key))
			return nil
		})
		if errormdl.CheckErr(err) != nil {
			return nil, errormdl.CheckErr(err)
		}
		return byteData, nil
	}
	return nil, errormdl.Wrap("ERROR: Could not Get key in nil db instance")
}

//AddRecord - To Add,append or update data into a bucket
func AddRecord(db *bolt.DB, bucket string, key string, data interface{}) error {
	if db != nil {
		entryBytes, err := json.Marshal(data)
		if errormdl.CheckErr(err) != nil {
			return errormdl.Wrap("Could not marshal entry json")
		}
		err = db.Update(func(tx *bolt.Tx) error {
			_, bktErr := tx.CreateBucketIfNotExists([]byte(bucket))
			if errormdl.CheckErr1(bktErr) != nil {
				return errormdl.CheckErr1(bktErr)
			}
			tx.Bucket([]byte(bucket)).Put([]byte(key), entryBytes)
			if errormdl.CheckErr2(err) != nil {
				return errormdl.CheckErr2(err)
			}
			return nil
		})
		return errormdl.CheckErr3(err)
	}
	return errormdl.Wrap("ERROR: Could not AddRecord in nil db instance")
}

// GetRecord - To get all data in bucket
func GetRecord(db *bolt.DB, bucket string) ([]byte, error) {
	if db != nil {
		var bucketData []interface{}
		err := db.View(func(tx *bolt.Tx) error {
			bkt := tx.Bucket([]byte(bucket))
			if bkt == nil {
				return errormdl.Wrap("Bucket not found: " + bucket)
			}
			cursor := bkt.Cursor()
			for k, v := cursor.First(); k != nil; k, v = cursor.Next() {
				var interfaceObj interface{}
				unmarshallErr := json.Unmarshal(v, &interfaceObj)
				if errormdl.CheckErr(unmarshallErr) != nil {
					return errormdl.CheckErr(unmarshallErr)
				}
				bucketData = append(bucketData, interfaceObj)
			}
			return nil
		})
		if errormdl.CheckErr1(err) != nil {
			return nil, errormdl.CheckErr1(err)
		}
		byteData, marshallErr := json.Marshal(bucketData)
		if errormdl.CheckErr2(marshallErr) != nil {
			return nil, errormdl.CheckErr2(marshallErr)
		}
		return byteData, nil
	}
	return nil, errormdl.Wrap("ERROR: Could not AddRecord in nil db instance")
}