package dbm

import (
	"bufio"
	"encoding/json"
	"fmt"
	"os"
	"strings"
	"sync"
	"time"

	"github.com/tecamino/tecamino-dbm/args"
	"github.com/tecamino/tecamino-dbm/models"
	ws "github.com/tecamino/tecamino-dbm/websocket"
	"github.com/tecamino/tecamino-logger/logging"
)

type DBMHandler struct {
	DBM   *models.DBM
	Conns *ws.ClientHandler
	sync.RWMutex
	Log      *logging.Logger
	arg      *args.Args
	filePath string
}

// initialze new Database Manager
// it will call cli arguments
func NewDbmHandler(a *args.Args) (*DBMHandler, error) {

	//initialize new logger
	logger, err := logging.NewLogger("dbmServer.log", &logging.Config{
		MaxSize:     1,
		MaxBackup:   3,
		MaxAge:      28,
		Debug:       a.Debug,
		TerminalOut: true,
	})

	if err != nil {
		return nil, err
	}
	logger.Info("main", "start dma handler")

	//initialize connection map
	conns := ws.NewConnectionHandler()

	// Initialize dtabase manager handler
	dmaHandler := DBMHandler{
		arg:      a,
		filePath: fmt.Sprintf("%s/%s.dbm", a.RootDir, a.DBMFile),
		DBM:      models.NewDBM(conns, logger),
		Log:      logger,
		Conns:    conns,
	}

	// initialize system datapoint and periodically update it
	if err := dmaHandler.AddSystemDps(); err != nil {
		return nil, err
	}

	// check if dtabase file exists to load data
	s := time.Now()
	if _, err := os.Stat(dmaHandler.filePath); err == nil {

		f, err := os.Open(dmaHandler.filePath)
		if err != nil {
			return nil, err
		}
		defer f.Close()

		// read in dtaabase file content
		scanner := bufio.NewScanner(f)
		var line int
		for scanner.Scan() {
			line++
			dp := &models.Datapoint{}
			if err = json.Unmarshal(scanner.Bytes(), dp); err != nil {
				dmaHandler.Log.Error("dmbHandler.NewDmbHandler", "error in line "+fmt.Sprint(line)+" "+scanner.Text())
				dmaHandler.Log.Error("dmbHandler.NewDmbHandler", err.Error())

				return nil, err
			}
			dmaHandler.DBM.ImportDatapoints(dp)
		}
	}
	dmaHandler.Log.Info("dmbHandler.NewDmbHandler", fmt.Sprintf("%d datapoint imported in %v", dmaHandler.DBM.GetNumbersOfDatapoints(), time.Since(s)))
	return &dmaHandler, nil
}

func (d *DBMHandler) SaveDb() (err error) {
	f, err := os.OpenFile(d.filePath, os.O_CREATE|os.O_RDWR|os.O_TRUNC, 0666)
	if err != nil {
		return err
	}
	defer f.Close()

	for _, dp := range d.DBM.GetAllDatapoints(0) {
		//exclude System datapoints from saving
		//System datapoints are used for internal purposes and should not be saved in the database
		if strings.Contains(dp.Path, "System:") {
			continue
		}

		b, er := json.Marshal(dp)
		if er != nil {
			return er
		}

		_, err = f.Write(b)
		if err != nil {
			return
		}
		_, err = f.Write([]byte("\n"))
		if err != nil {
			return
		}
	}
	return
}