// FindByEndnodeAddress returns an item which matches with endnode address.
func (db *DB) FindByEndnodeAddress(a common.EndnodeAddress) (common.MapItem, error) {
	n, ok := db.endnodeIndex[a.IDString()]
	if !ok {
		return common.MapItem{}, common.ErrUnknownEndnode
	}
	return db.items[n], nil
}

// UpsertEndnode updates or inserts a end-node with data.
func (db *DB) UpsertEndnode(ea common.EndnodeAddress, data []byte) (common.MapItem, error) {
	db.lock.Lock()
	defer db.lock.Unlock()

	// update data for a known end-node.
	id := ea.IDString()
	n, ok := db.endnodeIndex[id]
	if ok {
		db.items[n].States = data
		db.dumpTable()
		return db.items[n], nil
	}

	// check capacity.
	n = len(db.items)
	if n >= cap(db.items) {
		return common.MapItem{}, common.ErrTooManyEndnode
	}

	// insert a new end-node and its data.
	db.items = append(db.items, common.MapItem{
		EndnodeAddress: &ea,
		States:         data,
	})
	db.endnodeIndex[id] = n
	db.dumpTable()
	return db.items[n], nil
}

// RegisterEndnode registers cloud address for a end-node.
func (m *Mapper) RegisterEndnode(ea common.EndnodeAddress, ca common.CloudAddress) error {
	item, err := m.Store.UpdateCloud(ea, ca)
	if err != nil {
		return err
	}
	m.Log.Printf("mapped: endnodeID=%s cloudID=%s\n", ea.IDString(), ca.IDString())
	return m.Cloud.SendState(*item.CloudAddress, item.States)
}

// FindByEndnodeAddress returns an item which matches with endnode address.
func (m *DB) FindByEndnodeAddress(ea common.EndnodeAddress) (common.MapItem, error) {
	var item common.MapItem
	err := m.db.View(func(tx *bolt.Tx) (err error) {
		item, err = m.getMapItem(tx, []byte(ea.IDString()))
		return err
	})
	if err != nil {
		return common.MapItem{}, err
	}
	return item, nil
}

// UpdateThingProperties updates thing properties of endnode to locale DB.
func (m *Mapper) UpdateThingProperties(a common.EndnodeAddress, d []byte) error {
	item, err := m.Store.UpsertEndnodeProperties(a, d)
	if err != nil {
		return err
	}
	if item.CloudAddress == nil {
		m.Log.Printf("pended: endnodeID=%s ThingProperties=%s\n",
			a.IDString(), util.DataToString(d))
	}
	return nil
}

// UpdateStatus updates status of endnode and send it to cloud if need.
func (m *Mapper) UpdateStatus(a common.EndnodeAddress, d []byte) error {
	item, err := m.Store.UpsertEndnode(a, d)
	if err != nil {
		return err
	}
	if item.CloudAddress == nil {
		m.Log.Printf("pended: endnodeID=%s data=%s\n",
			a.IDString(), util.DataToString(d))
		return nil
	}
	return m.Cloud.SendState(*item.CloudAddress, item.States)
}

// UpdateCloud updates CloudAddress field of a end-node.
func (db *DB) UpdateCloud(ea common.EndnodeAddress, caddr common.CloudAddress) (common.MapItem, error) {
	db.lock.Lock()
	defer db.lock.Unlock()

	n, ok := db.endnodeIndex[ea.IDString()]
	if !ok {
		return common.MapItem{}, common.ErrUnknownEndnode
	}
	db.items[n].CloudAddress = &caddr
	db.cloudIndex[caddr.IDString()] = n
	db.dumpTable()
	return db.items[n], nil
}

func testUpdateCloud(t *testing.T, s mapper.Store, ea common.EndnodeAddress, ca common.CloudAddress) common.MapItem {
	m, err := s.UpdateCloud(ea, ca)
	if err != nil {
		t.Fatal("UpdateCloud failed:", err)
	}
	if m.EndnodeAddress == nil || m.EndnodeAddress.IDString() != ea.IDString() {
		t.Fatalf("UpdateCloud modified EndnodeAddress: %#v", m.EndnodeAddress)
	}
	if m.CloudAddress == nil || m.CloudAddress.IDString() != ca.IDString() {
		t.Fatalf("UpdateCloud returned unexpected CloudAddress: %#v",
			m.CloudAddress)
	}
	return m
}

func testUpsertEndnodeProperties(t *testing.T, s mapper.Store, ea common.EndnodeAddress, d []byte) common.MapItem {
	m, err := s.UpsertEndnodeProperties(ea, d)
	if err != nil {
		t.Fatal("UpsertEndnodeProperties failed:", err)
	}
	if m.EndnodeAddress == nil || m.EndnodeAddress.IDString() != ea.IDString() {
		t.Fatalf("UpsertEndnode returns unexpected MapItem: %#v",
			m.EndnodeAddress)
	}
	if !bytes.Equal(m.ThingProperties, d) {
		t.Fatalf("UpsertEndnode store wrong data: %#v (expecetd:%#v)",
			m.States, d)
	}
	return m
}

// UpdateCloud updates CloudAddress field of a end-node.
func (m *DB) UpdateCloud(ea common.EndnodeAddress, ca common.CloudAddress) (common.MapItem, error) {
	var item common.MapItem
	err := m.db.Update(func(tx *bolt.Tx) (err error) {
		item, err = m.getMapItem(tx, []byte(ea.IDString()))
		if err != nil {
			return err
		}
		item.CloudAddress = &ca
		return m.putMapItem(tx, item)
	})
	if err != nil {
		return common.MapItem{}, err
	}
	return item, nil
}

// UpdateEndnode update EndnodeAddress for existing endnode
func (db *DB) UpdateEndnode(newEA common.EndnodeAddress, caddr common.CloudAddress) (common.MapItem, error) {
	db.lock.Lock()
	defer db.lock.Unlock()

	// retrieve mapItem by cloudAddress
	item, err := db.FindByCloudAddress(caddr)
	if err != nil {
		return common.MapItem{}, err
	}
	n := db.cloudIndex[caddr.IDString()]
	// update endnodeIndex
	delete(db.endnodeIndex, item.EndnodeAddress.IDString())
	db.endnodeIndex[newEA.IDString()] = n

	// update mapitem
	db.items[n].EndnodeAddress = &newEA
	db.dumpTable()
	return db.items[n], nil
}

// UpsertEndnodeProperties updates or inserts a end-node with thing properties.
func (m *DB) UpsertEndnodeProperties(ea common.EndnodeAddress, data []byte) (common.MapItem, error) {
	var item common.MapItem
	err := m.db.Update(func(tx *bolt.Tx) (err error) {
		item, err = m.getMapItem(tx, []byte(ea.IDString()))
		if err != nil {
			if err != common.ErrUnknownEndnode {
				return err
			}
			item = common.MapItem{
				EndnodeAddress: &ea,
			}
		}
		item.ThingProperties = data
		return m.putMapItem(tx, item)
	})
	if err != nil {
		return common.MapItem{}, err
	}
	return item, nil
}