package main

import (
	"fmt"
	"log"
	"strings"
	"time"

	"github.com/currantlabs/gatt"
	"github.com/currantlabs/gatt/examples/option"
)

var done = make(chan struct{})

func onStateChanged(d gatt.Device, s gatt.State) {
	fmt.Println("State:", s)
	switch s {
	case gatt.StatePoweredOn:
		fmt.Println("scanning...")
		d.Scan([]gatt.UUID{}, false)
		return
	default:
		d.StopScanning()
	}
}

func onPeriphDiscovered(p gatt.Peripheral, a *gatt.Advertisement, rssi int) {
	ID := p.ID()
	//xiaomi scale
	if !strings.HasPrefix(ID, "88:0F:10") {
		return
	}

	fmt.Printf("\nPeripheral ID:%s, NAME:(%s)\n", ID, p.Name())

	fmt.Printf("%v+", a)
	fmt.Println("  Local Name        =", a.LocalName)
	fmt.Println("  TX Power Level    =", a.TxPowerLevel)
	fmt.Println("  Manufacturer Data =", a.ManufacturerData)
	fmt.Println("  Service Data      =", a.ServiceData)
	fmt.Println("  RSSI      =", rssi)

	p.Device().Connect(p)
}

func onPeriphConnected(p gatt.Peripheral, err error) {
	var WEIGHT_MEASUREMENT_SERVICE = gatt.MustParseUUID("181d")
	var WEIGHT_MEASUREMENT_HISTORY_CHARACTERISTIC = gatt.MustParseUUID("00002a2f-0000-3512-2118-0009af100700")
	var WEIGHT_MEASUREMENT_TIME_CHARACTERISTIC = gatt.MustParseUUID("2a2b")
	var WEIGHT_MEASUREMENT_CONFIG = gatt.MustParseUUID("2902")

	fmt.Println("Connected")
	defer p.Device().CancelConnection(p)

	if err := p.SetMTU(500); err != nil {
		fmt.Printf("Failed to set MTU, err: %s\n", err)
	}
	fmt.Printf("Set mtu done.\n")
	
	// Discovery services
	services, err := p.DiscoverServices(nil)
	fmt.Printf("Services: %v+", services)
	if err != nil {
		fmt.Printf("Failed to discover services, err: %s\n", err)
		return
	}

	service := getServiceByUUID(WEIGHT_MEASUREMENT_SERVICE, services)
	fmt.Printf("Service Found %s\n", service.Name())
	chars, _ := p.DiscoverCharacteristics(nil, service)

	char := getCharByUUID(WEIGHT_MEASUREMENT_TIME_CHARACTERISTIC, chars)
	b, err := p.ReadCharacteristic(char)
	if err != nil {
		fmt.Printf("Failed to read characteristic, err: %s\n", err)
		return
	}
	fmt.Printf("    value         %x | %q\n", b, b)

	histChar := getCharByUUID(WEIGHT_MEASUREMENT_HISTORY_CHARACTERISTIC, chars)
	descriptors, _ := p.DiscoverDescriptors(nil, histChar)
	descriptor := getDescriptorByUUID(WEIGHT_MEASUREMENT_CONFIG, descriptors)
	p.WriteDescriptor(descriptor, []byte{0x02, 0x00})

	p.SetNotifyValue(histChar, func(c *gatt.Characteristic, b []byte, e error) {
		log.Printf("Got back from %s: %#x\n", c.UUID(), b)
		//weight :=
		if len(b) == 20 {
			first := b[0:10]
			parseData(first)
			second := b[10:20]
			parseData(second)
		} else if len(b) == 10 {
			parseData(b)
		}
	})
	p.WriteCharacteristic(histChar, []byte{0x02}, true)

	fmt.Printf("Waiting for 5 seconds to get some notifiations, if any.\n")
	time.Sleep(10 * time.Second)
}

func getDescriptorByUUID(uuid gatt.UUID, descriptors []*gatt.Descriptor) *gatt.Descriptor {
	for _, descriptor := range descriptors {
		if !descriptor.UUID().Equal(uuid) {
			continue
		}
		return descriptor
	}
	return nil
}

func getServiceByUUID(uuid gatt.UUID, services []*gatt.Service) *gatt.Service {
	for _, service := range services {
		if !service.UUID().Equal(uuid) {
			continue
		}
		return service
	}
	return nil
}

func getCharByUUID(uid gatt.UUID, chars []*gatt.Characteristic) *gatt.Characteristic {
	for _, c := range chars {
		if !c.UUID().Equal(uid) {
			continue
		}
		return c
	}
	return nil
}

func onPeriphDisconnected(p gatt.Peripheral, err error) {
	fmt.Println("Disconnected")
	close(done)
}

func main() {
	d, err := gatt.NewDevice(option.DefaultClientOptions...)
	if err != nil {
		log.Fatalf("Failed to open device, err: %s\n", err)
		return
	}

	// Register handlers.
	d.Handle(
		gatt.PeripheralDiscovered(onPeriphDiscovered),
		gatt.PeripheralConnected(onPeriphConnected),
		gatt.PeripheralDisconnected(onPeriphDisconnected),
	)

	d.Init(onStateChanged)
	<-done
	fmt.Println("Done")
}