go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/experiments/huectl/pkg/hue/bridge.go

/*

Copyright (c) 2023 - Present. Will Charczuk. All rights reserved.
Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.

*/

package hue

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/url"
	"path"
	"strconv"
	"strings"
)

// Bridge exposes a hardware bridge through a struct.
type Bridge struct {
	ID       string `json:"id,omitempty"`
	Addr     string `json:"internalipaddress,omitempty"`
	Username string `json:"user,omitempty"`
}

func (b Bridge) getHostURL(pathSegments ...string) (*url.URL, error) {
	// if the "host" parameter doesn't have a schema, add it
	if strings.Index(strings.ToLower(b.Addr), "http://") <= -1 && strings.Index(strings.ToLower(b.Addr), "https://") <= -1 {
		b.Addr = fmt.Sprintf("%s%s", "http://", b.Addr)
	}

	u, err := url.Parse(b.Addr)
	if err != nil {
		return nil, err
	}
	u.Path = path.Join(append([]string{
		u.Path,
		"/api/",
		b.Username,
	}, pathSegments...)...)
	return u, nil
}

// Login calls New() and passes Host on this Bridge instance.
func (b Bridge) Login(username string) Bridge {
	b.Username = username
	return b
}

// GetConfig returns the bridge configuration
func (b Bridge) GetConfig(ctx context.Context) (*Config, error) {
	url, err := b.getHostURL("/config/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	var config Config
	err = unmarshal(res, &config)
	if err != nil {
		return nil, err
	}

	config.Whitelist = make([]Whitelist, 0, len(config.WhitelistMap))
	for k, v := range config.WhitelistMap {
		v.Username = k
		config.Whitelist = append(config.Whitelist, v)
	}
	return &config, nil
}

// CreateUser creates a user by adding n to the list of whitelists in the bridge.
// The link button on the bridge must have been pressed before calling CreateUser.
func (b Bridge) CreateUser(ctx context.Context, n string) (string, error) {
	wl, err := b.createUser(ctx, n, false)
	if err != nil {
		return "", err
	}

	return wl.Username, nil
}

// CreateUserWithClientKey creates a user by adding deviceType to the list of whitelisted users on the bridge
// The link button on the bridge must have been pressed before calling CreateUser.
func (b Bridge) CreateUserWithClientKey(ctx context.Context, deviceType string) (*Whitelist, error) {
	return b.createUser(ctx, deviceType, true)
}

func (b Bridge) createUser(ctx context.Context, deviceType string, generateClientKey bool) (*Whitelist, error) {
	var a []*APIResponse

	body := struct {
		DeviceType        string `json:"devicetype,omitempty"`
		GenerateClientKey bool   `json:"generateclientkey,omitempty"`
	}{deviceType, generateClientKey}

	url, err := b.getHostURL("/")
	if err != nil {
		return nil, err
	}

	data, err := json.Marshal(&body)
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	wl := Whitelist{
		Name:     deviceType,
		Username: resp.Success["username"].(string),
	}

	if ck, ok := resp.Success["clientkey"]; ok {
		wl.ClientKey = ck.(string)
	} else if generateClientKey {
		return nil, errors.New("no client key was returned when requested to generate")
	}

	return &wl, nil
}

// GetUsers returns a list of whitelists from the bridge
func (b Bridge) GetUsers(ctx context.Context) ([]Whitelist, error) {
	c, err := b.GetConfig(ctx)
	if err != nil {
		return nil, err
	}
	return c.Whitelist, nil
}

// UpdateConfig updates the bridge configuration with c
func (b Bridge) UpdateConfig(ctx context.Context, c *Config) (*Response, error) {
	var a []*APIResponse
	url, err := b.getHostURL("/config/")
	if err != nil {
		return nil, err
	}

	data, err := json.Marshal(&c)
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// DeleteUser removes a whitelist item from whitelists on the bridge
func (b Bridge) DeleteUser(ctx context.Context, n string) error {
	var a []*APIResponse

	url, err := b.getHostURL("/config/whitelist/", n)
	if err != nil {
		return err
	}

	res, err := delete(ctx, url.String())
	if err != nil {
		return err
	}

	_ = unmarshal(res, &a)

	_, err = handleResponse(a)
	if err != nil {
		return err
	}

	return nil

}

// GetFullState returns the entire bridge configuration.
func (b Bridge) GetFullState(ctx context.Context) (map[string]interface{}, error) {
	var n map[string]interface{}

	url, err := b.getHostURL("/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &n)
	if err != nil {
		return nil, err
	}

	return n, nil
}

// GetGroups returns all groups known to the bridge
func (b Bridge) GetGroups(ctx context.Context) ([]Group, error) {
	var m map[string]Group

	url, err := b.getHostURL("/groups/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &m)
	if err != nil {
		return nil, err
	}

	groups := make([]Group, 0, len(m))

	for i, g := range m {
		g.ID, err = strconv.Atoi(i)
		if err != nil {
			return nil, err
		}
		g.bridge = b
		groups = append(groups, g)
	}

	return groups, err
}

// GetGroup returns one group known to the bridge by its id
func (b Bridge) GetGroup(ctx context.Context, i int) (*Group, error) {
	g := &Group{
		bridge: b,
		ID:     i,
	}

	url, err := b.getHostURL("/groups/", strconv.Itoa(i))
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &g)
	if err != nil {
		return nil, err
	}

	g.bridge = b

	return g, nil
}

// SetGroupState allows for setting the state of one group, controlling the state of all lights in that group.
func (b Bridge) SetGroupState(ctx context.Context, i int, l LightState) (*Response, error) {
	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/groups/", id, "/action/")
	if err != nil {
		return nil, err
	}

	data, err := json.Marshal(&l)
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// UpdateGroup updates one group known to the bridge
func (b Bridge) UpdateGroup(ctx context.Context, i int, l Group) (*Response, error) {

	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/groups/", id)
	if err != nil {
		return nil, err
	}

	data, err := json.Marshal(&l)
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// CreateGroup creates one new group with attributes defined by g
func (b Bridge) CreateGroup(ctx context.Context, g Group) (*Response, error) {
	var a []*APIResponse

	url, err := b.getHostURL("/groups/")
	if err != nil {
		return nil, err
	}

	data, err := json.Marshal(&g)
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// DeleteGroup deletes one group with the id of i
func (b Bridge) DeleteGroup(ctx context.Context, i int) error {
	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/groups/", id)
	if err != nil {
		return err
	}

	res, err := delete(ctx, url.String())
	if err != nil {
		return err
	}

	_ = unmarshal(res, &a)

	_, err = handleResponse(a)
	if err != nil {
		return err
	}

	return nil
}

// GetLights returns all lights known to the bridge
func (b Bridge) GetLights(ctx context.Context) ([]Light, error) {
	m := map[string]Light{}

	url, err := b.getHostURL("/lights/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &m)
	if err != nil {
		return nil, err
	}

	lights := make([]Light, 0, len(m))

	for i, l := range m {
		l.ID, err = strconv.Atoi(i)
		if err != nil {
			return nil, err
		}
		l.bridge = b
		lights = append(lights, l)
	}

	return lights, nil
}

// GetLight returns one light with the id of i
func (b Bridge) GetLight(ctx context.Context, id int) (*Light, error) {
	light := &Light{
		ID: id,
	}

	url, err := b.getHostURL("/lights/", strconv.Itoa(id))
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return light, err
	}

	err = unmarshal(res, &light)
	if err != nil {
		return light, err
	}

	light.bridge = b
	return light, nil
}

// IdentifyLight allows identifying a light
func (b Bridge) IdentifyLight(ctx context.Context, i int) (*Response, error) {
	var a []*APIResponse

	url, err := b.getHostURL("/lights/", strconv.Itoa(i), "/state")
	if err != nil {
		return nil, err
	}
	res, err := put(ctx, url.String(), []byte(`{"alert":"select"}`))
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// SetLightState allows for controlling one light's state
func (b Bridge) SetLightState(ctx context.Context, i int, l LightState) (*Response, error) {
	var a []*APIResponse

	l.Reachable = false
	l.ColorMode = ""

	data, err := json.Marshal(&l)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/lights/", strconv.Itoa(i), "/state")
	if err != nil {
		return nil, err
	}
	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// FindLights starts a search for new lights on the bridge.
//
// Use GetNewLights() verify if new lights have been detected.
func (b Bridge) FindLights(ctx context.Context) (*Response, error) {
	var a []*APIResponse

	url, err := b.getHostURL("/lights/")
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), nil)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// GetNewLights returns a list of lights that were discovered last time FindLights() was executed.
func (b Bridge) GetNewLights(ctx context.Context) (*Lights, error) {
	var n map[string]interface{}

	url, err := b.getHostURL("/lights/new")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	_ = unmarshal(res, &n)

	lights := make([]string, 0, len(n))
	var lastscan string

	for k := range n {
		if k == "lastscan" {
			lastscan = n[k].(string)
		} else {
			lights = append(lights, k)
		}
	}

	result := &Lights{
		Lights:   lights,
		LastScan: lastscan,
	}
	return result, nil
}

// DeleteLight deletes one lights from the bridge
func (b Bridge) DeleteLight(ctx context.Context, i int) error {
	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/lights/", id)
	if err != nil {
		return err
	}

	res, err := delete(ctx, url.String())
	if err != nil {
		return err
	}

	_ = unmarshal(res, &a)

	_, err = handleResponse(a)
	if err != nil {
		return err
	}

	return nil
}

// UpdateLight updates one light's attributes and state properties
func (b Bridge) UpdateLight(ctx context.Context, i int, light Light) (*Response, error) {
	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/lights/", id)
	if err != nil {
		return nil, err
	}

	data, err := json.Marshal(&light)
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// GetResourcelinks returns all resourcelinks known to the bridge
func (b Bridge) GetResourcelinks(ctx context.Context) ([]*Resourcelink, error) {
	var r map[string]Resourcelink

	url, err := b.getHostURL("/resourcelinks/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &r)
	if err != nil {
		return nil, err
	}

	resourcelinks := make([]*Resourcelink, 0, len(r))

	for i, s := range r {
		s.ID, err = strconv.Atoi(i)
		if err != nil {
			return nil, err
		}
		sCopy := s
		resourcelinks = append(resourcelinks, &sCopy)
	}

	return resourcelinks, nil
}

// GetResourcelink returns one resourcelink by its id defined by i
func (b Bridge) GetResourcelink(ctx context.Context, i int) (*Resourcelink, error) {
	g := &Resourcelink{
		ID: i,
	}

	url, err := b.getHostURL("/resourcelinks/", strconv.Itoa(i))
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &g)
	if err != nil {
		return nil, err
	}

	return g, nil
}

// CreateResourcelink creates one new resourcelink on the bridge
func (b Bridge) CreateResourcelink(ctx context.Context, s *Resourcelink) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&s)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/resourcelinks/")
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// UpdateResourcelink updates one resourcelink with attributes defined by resourcelink
func (b Bridge) UpdateResourcelink(ctx context.Context, i int, resourcelink *Resourcelink) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&resourcelink)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/resourcelinks/", strconv.Itoa(i))
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// DeleteResourcelink deletes one resourcelink with the id of i
func (b Bridge) DeleteResourcelink(ctx context.Context, i int) error {
	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/resourcelinks/", id)
	if err != nil {
		return err
	}

	res, err := delete(ctx, url.String())
	if err != nil {
		return err
	}

	_ = unmarshal(res, &a)

	_, err = handleResponse(a)
	if err != nil {
		return err
	}

	return nil
}

// GetRules returns all rules known to the bridge
func (b Bridge) GetRules(ctx context.Context) ([]*Rule, error) {
	var r map[string]Rule

	url, err := b.getHostURL("/rules/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &r)
	if err != nil {
		return nil, err
	}

	rules := make([]*Rule, 0, len(r))

	for i, s := range r {
		s.ID, err = strconv.Atoi(i)
		if err != nil {
			return nil, err
		}
		sCopy := s
		rules = append(rules, &sCopy)
	}

	return rules, nil
}

// GetRule returns one rule by its id of i
func (b Bridge) GetRule(ctx context.Context, i int) (*Rule, error) {
	g := &Rule{
		ID: i,
	}

	url, err := b.getHostURL("/rules/", strconv.Itoa(i))
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &g)
	if err != nil {
		return nil, err
	}

	return g, nil
}

// CreateRule creates one rule with attribues defined in s
func (b Bridge) CreateRule(ctx context.Context, s *Rule) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&s)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/rules/")
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// UpdateRule updates one rule by its id of i and rule configuration of rule
func (b Bridge) UpdateRule(ctx context.Context, i int, rule *Rule) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&rule)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/rules/", strconv.Itoa(i))
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// DeleteRule deletes one rule from the bridge
func (b Bridge) DeleteRule(ctx context.Context, i int) error {
	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/rules/", id)
	if err != nil {
		return err
	}

	res, err := delete(ctx, url.String())
	if err != nil {
		return err
	}

	_ = unmarshal(res, &a)

	_, err = handleResponse(a)
	if err != nil {
		return err
	}

	return nil
}

// GetScenes returns all scenes known to the bridge
func (b Bridge) GetScenes(ctx context.Context) ([]Scene, error) {
	var m map[string]Scene

	url, err := b.getHostURL("/scenes/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &m)
	if err != nil {
		return nil, err
	}
	scenes := make([]Scene, 0, len(m))

	for i, s := range m {
		s.ID = i
		s.bridge = b
		scenes = append(scenes, s)
	}

	return scenes, nil
}

// GetScene returns one scene by its id of i
func (b Bridge) GetScene(ctx context.Context, i string) (*Scene, error) {
	g := &Scene{ID: i}
	l := struct {
		LightStates map[int]LightState `json:"lightstates"`
	}{}

	url, err := b.getHostURL("/scenes/", i)
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &l)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &g)
	if err != nil {
		return nil, err
	}

	g.bridge = b

	return g, nil
}

// UpdateScene updates one scene and its attributes by id of i
func (b Bridge) UpdateScene(ctx context.Context, id string, s *Scene) (*Response, error) {
	var a []*APIResponse

	url, err := b.getHostURL("/scenes/", id)
	if err != nil {
		return nil, err
	}

	data, err := json.Marshal(&s)
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// SetSceneLightState allows for setting the state of a light in a scene.
func (b Bridge) SetSceneLightState(ctx context.Context, id string, iid int, l *LightState) (*Response, error) {
	var a []*APIResponse

	lightid := strconv.Itoa(iid)
	url, err := b.getHostURL("scenes", id, "lightstates", lightid)
	if err != nil {
		return nil, err
	}

	data, err := json.Marshal(&l)
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// RecallScene will recall a scene in a group identified by both scene and group identifiers
func (b Bridge) RecallScene(ctx context.Context, id string, gid int) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(struct {
		Scene string `json:"scene"`
	}{id})

	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/groups/", strconv.Itoa(gid), "/action")
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, err
}

// CreateScene creates one new scene with its attributes defined in s
func (b Bridge) CreateScene(ctx context.Context, s *Scene) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&s)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/scenes/")
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// DeleteScene deletes one scene from the bridge
func (b Bridge) DeleteScene(ctx context.Context, id string) error {
	var a []*APIResponse

	url, err := b.getHostURL("/scenes/", id)
	if err != nil {
		return err
	}

	res, err := delete(ctx, url.String())
	if err != nil {
		return err
	}

	_ = unmarshal(res, &a)

	_, err = handleResponse(a)
	if err != nil {
		return err
	}

	return nil
}

// GetSchedules returns all schedules known to the bridge
func (b Bridge) GetSchedules(ctx context.Context) ([]*Schedule, error) {
	var r map[string]Schedule

	url, err := b.getHostURL("/schedules/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &r)
	if err != nil {
		return nil, err
	}

	schedules := make([]*Schedule, 0, len(r))

	for i, s := range r {
		s.ID, err = strconv.Atoi(i)
		if err != nil {
			return nil, err
		}
		sCopy := s
		schedules = append(schedules, &sCopy)
	}

	return schedules, nil
}

// GetSchedule returns one schedule by id defined in i
func (b Bridge) GetSchedule(ctx context.Context, i int) (*Schedule, error) {
	g := &Schedule{
		ID: i,
	}

	url, err := b.getHostURL("/schedules/", strconv.Itoa(i))
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &g)
	if err != nil {
		return nil, err
	}

	return g, nil
}

// CreateSchedule creates one schedule and sets its attributes defined in s
func (b Bridge) CreateSchedule(ctx context.Context, s *Schedule) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&s)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/schedules/")
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// UpdateSchedule updates one schedule by its id of i and attributes by schedule
func (b Bridge) UpdateSchedule(ctx context.Context, i int, schedule *Schedule) (*Response, error) {

	var a []*APIResponse

	data, err := json.Marshal(&schedule)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/schedules/", strconv.Itoa(i))
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// DeleteSchedule deletes one schedule from the bridge by its id of i
func (b Bridge) DeleteSchedule(ctx context.Context, i int) error {
	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/schedules/", id)
	if err != nil {
		return err
	}

	res, err := delete(ctx, url.String())
	if err != nil {
		return err
	}

	_ = unmarshal(res, &a)

	_, err = handleResponse(a)
	if err != nil {
		return err
	}

	return nil
}

// GetSensors returns all sensors known to the bridge
func (b Bridge) GetSensors(ctx context.Context) ([]Sensor, error) {
	s := map[string]Sensor{}

	url, err := b.getHostURL("/sensors/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &s)
	if err != nil {
		return nil, err
	}

	sensors := make([]Sensor, 0, len(s))

	for i, k := range s {
		k.ID, err = strconv.Atoi(i)
		if err != nil {
			return nil, err
		}
		sensors = append(sensors, k)
	}
	return sensors, err
}

// GetSensor returns one sensor by its id of i
func (b Bridge) GetSensor(ctx context.Context, i int) (*Sensor, error) {
	r := &Sensor{
		ID: i,
	}

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/sensors/", id)
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return r, err
	}

	err = unmarshal(res, &r)
	if err != nil {
		return r, err
	}

	return r, err
}

// CreateSensor creates one new sensor
func (b Bridge) CreateSensor(ctx context.Context, s *Sensor) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&s)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/sensors/")
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// FindSensors starts a search for new sensors.
func (b Bridge) FindSensors(ctx context.Context) (*Response, error) {
	var a []*APIResponse

	url, err := b.getHostURL("/sensors/")
	if err != nil {
		return nil, err
	}

	res, err := post(ctx, url.String(), nil)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// GetNewSensors returns a list of sensors that were discovered last time GetNewSensors() was executed.
func (b Bridge) GetNewSensors(ctx context.Context) (*Sensors, error) {
	var n map[string]Sensor
	var result *Sensors

	url, err := b.getHostURL("/sensors/new")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	_ = unmarshal(res, &n)

	sensors := make([]Sensor, 0, len(n))

	for i, l := range n {
		if i != "lastscan" {
			l.ID, err = strconv.Atoi(i)
			if err != nil {
				return nil, err
			}
			lCopy := l
			sensors = append(sensors, lCopy)
		}
	}

	err = unmarshal(res, &result)
	if err != nil {
		return nil, err
	}

	resu := &Sensors{sensors, result.LastScan}
	return resu, nil
}

// UpdateSensor updates one sensor by its id and attributes by sensor
func (b Bridge) UpdateSensor(ctx context.Context, i int, sensor *Sensor) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&sensor)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/sensors/", strconv.Itoa(i))
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// DeleteSensor deletes one sensor from the bridge
func (b Bridge) DeleteSensor(ctx context.Context, i int) error {
	var a []*APIResponse

	id := strconv.Itoa(i)
	url, err := b.getHostURL("/sensors/", id)
	if err != nil {
		return err
	}

	res, err := delete(ctx, url.String())
	if err != nil {
		return err
	}

	_ = unmarshal(res, &a)

	_, err = handleResponse(a)
	if err != nil {
		return err
	}

	return nil
}

// UpdateSensorConfig updates the configuration of one sensor. The allowed configuration parameters depend on the sensor type
func (b Bridge) UpdateSensorConfig(ctx context.Context, i int, c interface{}) (*Response, error) {
	var a []*APIResponse

	data, err := json.Marshal(&c)
	if err != nil {
		return nil, err
	}

	url, err := b.getHostURL("/sensors/", strconv.Itoa(i), "/config")
	if err != nil {
		return nil, err
	}

	res, err := put(ctx, url.String(), data)
	if err != nil {
		return nil, err
	}

	err = unmarshal(res, &a)
	if err != nil {
		return nil, err
	}

	resp, err := handleResponse(a)
	if err != nil {
		return nil, err
	}

	return resp, nil
}

// GetCapabilities returns a list of capabilities of resources supported in the bridge.
func (b Bridge) GetCapabilities(ctx context.Context) (*Capabilities, error) {
	url, err := b.getHostURL("/capabilities/")
	if err != nil {
		return nil, err
	}

	res, err := get(ctx, url.String())
	if err != nil {
		return nil, err
	}

	var s Capabilities
	err = unmarshal(res, &s)
	if err != nil {
		return nil, err
	}

	return &s, err
}