lucifer/light/service.go

package light

import (
	"context"
	"log"
	"net/http"
	"sync"
	"time"

	"git.aiterp.net/lucifer/lucifer/internal/httperr"
	"git.aiterp.net/lucifer/lucifer/models"
)

// ErrUnknownDriver is returned by any function asking for a driver name if the driver specified doesn't exist.
var ErrUnknownDriver = httperr.Error{Status: http.StatusNotImplemented, Kind: "unknown_driver", Message: "Unknown light driver"}

// A Service wraps the repos for lights and bridges and takes care of the business logic.
type Service struct {
	mutex sync.Mutex

	bridges models.BridgeRepository
	lights  models.LightRepository
}

// DirectConnect connects to a bridge directly, without going through the discovery process to find them..
func (s *Service) DirectConnect(ctx context.Context, driver string, addr string, name string) (models.Bridge, error) {
	d, ok := drivers[driver]
	if !ok {
		return models.Bridge{}, ErrUnknownDriver
	}

	bridge := models.Bridge{
		ID:     -1,
		Name:   name,
		Addr:   addr,
		Driver: driver,
	}

	bridge, err := d.Connect(ctx, bridge)
	if err != nil {
		return models.Bridge{}, httperr.Error{Status: http.StatusPreconditionFailed, Kind: "connect_failed", Message: err.Error()}
	}

	bridge, err = s.bridges.Insert(ctx, bridge)
	if err != nil {
		return models.Bridge{}, err
	}

	return bridge, nil
}

// SyncLights syncs all lights in a bridge with the state in the database.
func (s *Service) SyncLights(ctx context.Context, bridge models.Bridge) error {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	d, ok := drivers[bridge.Driver]
	if !ok {
		return ErrUnknownDriver
	}

	bridgeLights, err := d.Lights(ctx, bridge)
	if err != nil {
		return err
	}

	dbLights, err := s.lights.ListByBridge(ctx, bridge)
	if err != nil {
		return err
	}

	// Add unknown lights
	for _, bridgeLight := range bridgeLights {
		found := false
		for _, dbLight := range dbLights {
			if dbLight.InternalID == bridgeLight.InternalID {
				found = true
				break
			}
		}

		// Add unknown lights if it doesn't exist in the databse.
		if !found {
			log.Println("Adding unknown light", bridgeLight.InternalID)
			bridgeLight.SetColor("FFFFFF")
			bridgeLight.Brightness = 254
			_, err := s.lights.Insert(ctx, bridgeLight)
			if err != nil {
				return err
			}
		}
	}

	changedLights, err := d.ChangedLights(ctx, bridge, dbLights...)
	if err != nil {
		return err
	}

	if len(changedLights) > 0 {
		err := d.Apply(ctx, bridge, changedLights...)
		if err != nil {
			log.Printf("Failed to apply one or more of the changes on bridge %d (%s): %s", bridge.ID, bridge.Name, err)
		}
	}

	return nil
}

// UpdateLight updates the light immediately.
func (s *Service) UpdateLight(ctx context.Context, light models.Light) error {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	err := s.lights.Update(ctx, light)
	if err != nil {
		return err
	}

	bridge, err := s.bridges.FindByID(ctx, light.BridgeID)
	if err != nil {
		return httperr.NotFound("Bridge")
	}
	d, ok := drivers[bridge.Driver]
	if !ok {
		return ErrUnknownDriver
	}

	return d.Apply(ctx, bridge, light)
}

// SyncLoop runs synclight on all bridges twice every second until the context is
// done.
func (s *Service) SyncLoop(ctx context.Context) {
	interval := time.NewTicker(time.Millisecond * 2500)

	for {
		select {
		case <-interval.C:
			{
				bridges, err := s.Bridges(context.Background())
				if err != nil {
					log.Println("Could not get bridges:", err)
				}

				for _, bridge := range bridges {
					err = s.SyncLights(ctx, bridge)
					if err != nil {
						log.Println("Sync failed:", err)
					}
				}
			}
		case <-ctx.Done():
			{
				log.Println("Sync loop stopped.")
				return
			}
		}
	}
}

// Bridge gets a bridge by ID.
func (s *Service) Bridge(ctx context.Context, id int) (models.Bridge, error) {
	return s.bridges.FindByID(ctx, id)
}

// Bridges gets all known bridges.
func (s *Service) Bridges(ctx context.Context) ([]models.Bridge, error) {
	return s.bridges.List(ctx)
}

// DeleteBridge deletes the bridge.
func (s *Service) DeleteBridge(ctx context.Context, bridge models.Bridge) error {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	err := s.bridges.Remove(ctx, bridge)
	if err != nil {
		return err
	}

	lights, err := s.lights.ListByBridge(ctx, bridge)
	if err != nil {
		return err
	}

	for _, light := range lights {
		err := s.lights.Remove(ctx, light)
		if err != nil {
			return err
		}
	}

	return nil
}

// UpdateBridge updates a bridge.
func (s *Service) UpdateBridge(ctx context.Context, bridge models.Bridge) error {
	s.mutex.Lock()
	defer s.mutex.Unlock()

	err := s.bridges.Update(ctx, bridge)
	if err != nil {
		return err
	}

	return nil
}

// DiscoverLights discovers new lights.
func (s *Service) DiscoverLights(ctx context.Context, bridge models.Bridge) error {
	d, ok := drivers[bridge.Driver]
	if !ok {
		return ErrUnknownDriver
	}

	return d.DiscoverLights(ctx, bridge)
}

// NewService creates a new light.Service.
func NewService(bridges models.BridgeRepository, lights models.LightRepository) *Service {
	return &Service{
		bridges: bridges,
		lights:  lights,
	}
}