package driver

import (
	"artNet/cfg"
	"artNet/models"
	ws "artNet/websocket"
	"encoding/json"
	"fmt"
	"path"

	json_data "github.com/tecamino/tecamino-json_data"
	"github.com/tecamino/tecamino-logger/logging"
)

type ArtNetDriver struct {
	Name          string                 `yaml:"driver" json:"driver"`
	Buses         map[string]*models.Bus `yaml:"buses,omitempty" json:"buses,omitempty"`
	cfgHandler    *cfg.Cfg               `yaml:"-" json:"-"`
	Subscriptions models.Subscriptions   `yaml:"-" json:"-"`
	Log           *logging.Logger        `yaml:"-" json:"-"`
}

// initialize new Art-Net driver
// cfgDir config directory
// name name of driver
func NewDriver(cfgDir, name string, debug bool) (*ArtNetDriver, error) {
	if cfgDir == "" {
		cfgDir = "./cfg"
	}

	logger, err := logging.NewLogger(path.Join(cfgDir, name+".log"), &logging.Config{
		MaxSize:     1,
		MaxBackup:   3,
		MaxAge:      28,
		Debug:       debug,
		TerminalOut: true,
	})
	if err != nil {
		panic(err)
	}

	logger.Debug("artNet.NewDriver", "initialize "+name+" driver")
	d := ArtNetDriver{
		Name:       name,
		Buses:      make(map[string]*models.Bus),
		cfgHandler: cfg.NewCfgHandler(cfgDir, name),
		Log:        logger,
	}

	if err := d.LoadCfg(); err != nil {
		logger.Error("artNet.NewDriver.LoadCfg", "error load driver configuration: "+err.Error())
		return nil, err
	}
	return &d, nil
}

// loads driver config
func (d *ArtNetDriver) LoadCfg() error {
	d.Log.Debug("artNet.LoadCfg", "load driver configuration")
	if err := d.cfgHandler.LoadCfg(d); err != nil {
		return err
	}

	for name, b := range d.Buses {
		d.NewBus(name, b.Ip, *b.Port)
	}
	return nil
}

// adds new Art-Net bus/interface to driver port 0 = 6454 (default art-net)
func (d *ArtNetDriver) NewBus(name, ip string, port int) *models.Bus {
	b := models.NewBus(name, ip, port)
	d.Buses[name] = b
	return b
}

func (d *ArtNetDriver) SetValue(bus string, address uint, value uint8) error {
	if _, ok := d.Buses[bus]; !ok {
		return fmt.Errorf("no bus '%s' found", bus)
	}
	if d.Buses[bus].Data == nil {
		return fmt.Errorf("no dmx data on bus '%s' found", bus)
	}
	d.Buses[bus].Data.SetValue(address, value)
	return nil
}

// connect to websocket server and listen to subscriptions
// ip: ip address of server
// id: id of driver
// port: port of server
func (d *ArtNetDriver) Connect(ip, id string, port uint) error {
	errChan := make(chan error)
	client, err := ws.NewClient(ip, id, port)
	if err != nil {
		return err
	}

	client.OnError = func(err error) {
		d.Log.Error("websocket connection", err)
		errChan <- err
	}

	client.OnMessage = func(data []byte) {

		request := json_data.NewResponse()
		err = json.Unmarshal(data, &request)
		if err != nil {
			return
		}
		if request.Subscribe != nil {
			d.Subscribe(request.Subscribe...)
		}
		if request.Publish != nil {
			d.Publish(request.Publish...)
		}
	}

	if err != nil {
		d.Log.Error("artNet.Connect", err)
		return err
	}

	req := json_data.NewRequest()
	req.AddDriverSubscription(".*", id, 0, true, false, false)

	if err := client.SendRequest(req); err != nil {
		errChan <- err
		d.Log.Error("websocket send data", err)
	}

	for err := range errChan {
		return err
	}
	return nil
}

// send data to all buses that the send flage is true
func (d *ArtNetDriver) SendData() {
	for _, bus := range d.Buses {
		bus.Send <- bus.Data
	}
}