package goble

import "C"

import (
	"bytes"
	"encoding/binary"
	"fmt"
	"log"
	"time"

	"github.com/raff/goble/xpc"
)

// "github.com/raff/goble/xpc"
//
// BLE support
//

var STATES = []string{"unknown", "resetting", "unsupported", "unauthorized", "poweredOff", "poweredOn"}

type Property int

const (
	Broadcast                 Property = 1 << iota
	Read                               = 1 << iota
	WriteWithoutResponse               = 1 << iota
	Write                              = 1 << iota
	Notify                             = 1 << iota
	Indicate                           = 1 << iota
	AuthenticatedSignedWrites          = 1 << iota
	ExtendedProperties                 = 1 << iota
)

func (p Property) Readable() bool {
	return (p & Read) != 0
}

func (p Property) String() (result string) {
	if (p & Broadcast) != 0 {
		result += "broadcast "
	}
	if (p & Read) != 0 {
		result += "read "
	}
	if (p & WriteWithoutResponse) != 0 {
		result += "writeWithoutResponse "
	}
	if (p & Write) != 0 {
		result += "write "
	}
	if (p & Notify) != 0 {
		result += "notify "
	}
	if (p & Indicate) != 0 {
		result += "indicate "
	}
	if (p & AuthenticatedSignedWrites) != 0 {
		result += "authenticateSignedWrites "
	}
	if (p & ExtendedProperties) != 0 {
		result += "extendedProperties "
	}

	return
}

type ServiceData struct {
	Uuid string
	Data []byte
}

type CharacteristicDescriptor struct {
	Uuid   string
	Handle int
}

type ServiceCharacteristic struct {
	Uuid        string
	Name        string
	Type        string
	Properties  Property
	Descriptors map[interface{}]*CharacteristicDescriptor
	Handle      int
	ValueHandle int
}

type ServiceHandle struct {
	Uuid            string
	Name            string
	Type            string
	Characteristics map[interface{}]*ServiceCharacteristic
	startHandle     int
	endHandle       int
}

type Advertisement struct {
	LocalName        string
	TxPowerLevel     int
	ManufacturerData []byte
	ServiceData      []ServiceData
	ServiceUuids     []string
}

type Peripheral struct {
	Uuid          xpc.UUID
	Address       string
	AddressType   string
	Connectable   bool
	Advertisement Advertisement
	Rssi          int
	Services      map[interface{}]*ServiceHandle
}

// GATT Descriptor
type Descriptor struct {
	uuid  xpc.UUID
	value []byte
}

// GATT Characteristic
type Characteristic struct {
	uuid        xpc.UUID
	properties  Property
	secure      Property
	descriptors []Descriptor
	value       []byte
}

// GATT Service
type Service struct {
	uuid            xpc.UUID
	characteristics []Characteristic
}

type BLE struct {
	Emitter
	conn    xpc.XPC
	verbose bool

	peripherals            map[string]*Peripheral
	attributes             xpc.Array
	lastServiceAttributeId int
	allowDuplicates        bool
}

func New() *BLE {
	ble := &BLE{peripherals: map[string]*Peripheral{}, Emitter: Emitter{}}
	ble.Emitter.Init()
	ble.conn = xpc.XpcConnect("com.apple.blued", ble)
	return ble
}

func (ble *BLE) SetVerbose(v bool) {
	ble.verbose = v
	ble.Emitter.SetVerbose(v)
}

// process BLE events and asynchronous errors
// (implements XpcEventHandler)
func (ble *BLE) HandleXpcEvent(event xpc.Dict, err error) {
	if err != nil {
		log.Println("error:", err)
		if event == nil {
			return
		}
	}

	id := event.MustGetInt("kCBMsgId")
	args := event.MustGetDict("kCBMsgArgs")

	if ble.verbose {
		log.Printf("event: %v %#v\n", id, args)
		defer log.Printf("done event: %v", id)
	}

	switch id {
	case 6: // state change
		state := args.MustGetInt("kCBMsgArgState")
		ble.Emit(Event{Name: "stateChange", State: STATES[state]})

	case 16: // advertising start
		result := args.MustGetInt("kCBMsgArgResult")
		if result != 0 {
			log.Printf("event: error in advertisingStart %v\n", result)
		} else {
			ble.Emit(Event{Name: "advertisingStart"})
		}

	case 17: // advertising stop
		result := args.MustGetInt("kCBMsgArgResult")
		if result != 0 {
			log.Printf("event: error in advertisingStop %v\n", result)
		} else {
			ble.Emit(Event{Name: "advertisingStop"})
		}

	case 37: // discover
		advdata := args.MustGetDict("kCBMsgArgAdvertisementData")
		if len(advdata) == 0 {
			//log.Println("event: discover with no advertisment data")
			break
		}

		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")

		advertisement := Advertisement{
			LocalName:        advdata.GetString("kCBAdvDataLocalName", args.GetString("kCBMsgArgName", "")),
			TxPowerLevel:     advdata.GetInt("kCBAdvDataTxPowerLevel", 0),
			ManufacturerData: advdata.GetBytes("kCBAdvDataManufacturerData", nil),
			ServiceData:      []ServiceData{},
			ServiceUuids:     []string{},
		}

		connectable := advdata.GetInt("kCBAdvDataIsConnectable", 0) > 0
		rssi := args.GetInt("kCBMsgArgRssi", 0)

		if uuids, ok := advdata["kCBAdvDataServiceUUIDs"]; ok {
			for _, uuid := range uuids.(xpc.Array) {
				advertisement.ServiceUuids = append(advertisement.ServiceUuids, fmt.Sprintf("%x", uuid))
			}
		}

		if data, ok := advdata["kCBAdvDataServiceData"]; ok {
			sdata := data.(xpc.Array)

			for i := 0; i < len(sdata); i += 2 {
				sd := ServiceData{
					Uuid: fmt.Sprintf("%x", sdata[i+0].([]byte)),
					Data: sdata[i+1].([]byte),
				}

				advertisement.ServiceData = append(advertisement.ServiceData, sd)
			}
		}

		pid := deviceUuid.String()
		p := ble.peripherals[pid]
		emit := ble.allowDuplicates || p == nil

		if p == nil {
			// add new peripheral
			p = &Peripheral{
				Uuid:          deviceUuid,
				Connectable:   connectable,
				Advertisement: advertisement,
				Rssi:          rssi,
				Services:      map[interface{}]*ServiceHandle{},
			}

			ble.peripherals[pid] = p
		} else {
			// update peripheral
			p.Advertisement = advertisement
			p.Rssi = rssi
		}

		if emit {
			ble.Emit(Event{Name: "discover", DeviceUUID: deviceUuid, Peripheral: *p})
		}

	case 38: // connect
		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")
		ble.Emit(Event{Name: "connect", DeviceUUID: deviceUuid})

	case 40: // disconnect
		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")
		ble.Emit(Event{Name: "disconnect", DeviceUUID: deviceUuid})

	case 53: // mtuChange
		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")
		mtu := args.MustGetInt("kCBMsgArgATTMTU")

		// bleno here converts the deviceUuid to an address
		if p, ok := ble.peripherals[deviceUuid.String()]; ok {
			ble.Emit(Event{Name: "mtuChange", DeviceUUID: deviceUuid, Peripheral: *p, Mtu: mtu})
		}

	case 54: // serviceDiscover
		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")
		servicesUuids := []string{}
		servicesHandles := map[interface{}]*ServiceHandle{}

		if dservices, ok := args["kCBMsgArgServices"]; ok {
			for _, s := range dservices.(xpc.Array) {
				service := s.(xpc.Dict)
				serviceHandle := ServiceHandle{
					Uuid:            service.MustGetHexBytes("kCBMsgArgUUID"),
					startHandle:     service.MustGetInt("kCBMsgArgServiceStartHandle"),
					endHandle:       service.MustGetInt("kCBMsgArgServiceEndHandle"),
					Characteristics: map[interface{}]*ServiceCharacteristic{}}

				if nameType, ok := knownServices[serviceHandle.Uuid]; ok {
					serviceHandle.Name = nameType.Name
					serviceHandle.Type = nameType.Type
				}

				servicesHandles[serviceHandle.Uuid] = &serviceHandle
				servicesHandles[serviceHandle.startHandle] = &serviceHandle

				servicesUuids = append(servicesUuids, serviceHandle.Uuid)
			}
		}

		if p, ok := ble.peripherals[deviceUuid.String()]; ok {
			p.Services = servicesHandles
			ble.Emit(Event{Name: "servicesDiscover", DeviceUUID: deviceUuid, Peripheral: *p})
		}

	case 55: // rssiUpdate
		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")
		rssi := args.MustGetInt("kCBMsgArgData")

		if p, ok := ble.peripherals[deviceUuid.String()]; ok {
			p.Rssi = rssi
			ble.Emit(Event{Name: "rssiUpdate", DeviceUUID: deviceUuid, Peripheral: *p})
		}

	case 63: // characteristicsDiscover
		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")
		serviceStartHandle := args.MustGetInt("kCBMsgArgServiceStartHandle")

		if p, ok := ble.peripherals[deviceUuid.String()]; ok {
			service := p.Services[serviceStartHandle]

			//result := args.MustGetInt("kCBMsgArgResult")

			for _, c := range args.MustGetArray("kCBMsgArgCharacteristics") {
				cDict := c.(xpc.Dict)

				characteristic := ServiceCharacteristic{
					Uuid:        cDict.MustGetHexBytes("kCBMsgArgUUID"),
					Handle:      cDict.MustGetInt("kCBMsgArgCharacteristicHandle"),
					ValueHandle: cDict.MustGetInt("kCBMsgArgCharacteristicValueHandle"),
					Descriptors: map[interface{}]*CharacteristicDescriptor{},
				}

				if nameType, ok := knownCharacteristics[characteristic.Uuid]; ok {
					characteristic.Name = nameType.Name
					characteristic.Type = nameType.Type
				}

				properties := cDict.MustGetInt("kCBMsgArgCharacteristicProperties")

				if (properties & 0x01) != 0 {
					characteristic.Properties |= Broadcast
				}

				if (properties & 0x02) != 0 {
					characteristic.Properties |= Read
				}

				if (properties & 0x04) != 0 {
					characteristic.Properties |= WriteWithoutResponse
				}

				if (properties & 0x08) != 0 {
					characteristic.Properties |= Write
				}

				if (properties & 0x10) != 0 {
					characteristic.Properties |= Notify
				}

				if (properties & 0x20) != 0 {
					characteristic.Properties |= Indicate
				}

				if (properties & 0x40) != 0 {
					characteristic.Properties |= AuthenticatedSignedWrites
				}

				if (properties & 0x80) != 0 {
					characteristic.Properties |= ExtendedProperties
				}

				if service != nil {
					service.Characteristics[characteristic.Uuid] = &characteristic
					service.Characteristics[characteristic.Handle] = &characteristic
					service.Characteristics[characteristic.ValueHandle] = &characteristic
				}
			}

			if service != nil {
				ble.Emit(Event{Name: "characteristicsDiscover", DeviceUUID: deviceUuid, ServiceUuid: service.Uuid, Peripheral: *p})
			} else {
				log.Println("no service", serviceStartHandle)
			}
		} else {
			log.Println("no peripheral", deviceUuid)
		}

	case 75: // descriptorsDiscover
		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")
		characteristicsHandle := args.MustGetInt("kCBMsgArgCharacteristicHandle")
		//result := args.MustGetInt("kCBMsgArgResult")

		if p, ok := ble.peripherals[deviceUuid.String()]; ok {
			for _, s := range p.Services {
				if c, ok := s.Characteristics[characteristicsHandle]; ok {
					for _, d := range args.MustGetArray("kCBMsgArgDescriptors") {
						dDict := d.(xpc.Dict)
						descriptor := CharacteristicDescriptor{
							Uuid:   dDict.MustGetHexBytes("kCBMsgArgUUID"),
							Handle: dDict.MustGetInt("kCBMsgArgDescriptorHandle"),
						}

						c.Descriptors[descriptor.Uuid] = &descriptor
						c.Descriptors[descriptor.Handle] = &descriptor
					}

					ble.Emit(Event{Name: "descriptorsDiscover", DeviceUUID: deviceUuid, ServiceUuid: s.Uuid, CharacteristicUuid: c.Uuid, Peripheral: *p})
					break
				}
			}
		} else {
			log.Println("no peripheral", deviceUuid)
		}

	case 70: // read
		deviceUuid := args.MustGetUUID("kCBMsgArgDeviceUUID")
		characteristicsHandle := args.MustGetInt("kCBMsgArgCharacteristicHandle")
		//result := args.MustGetInt("kCBMsgArgResult")
		isNotification := args.GetInt("kCBMsgArgIsNotification", 0) != 0
		data := args.MustGetBytes("kCBMsgArgData")

		if p, ok := ble.peripherals[deviceUuid.String()]; ok {
			for _, s := range p.Services {
				if c, ok := s.Characteristics[characteristicsHandle]; ok {
					ble.Emit(Event{Name: "read", DeviceUUID: deviceUuid, ServiceUuid: s.Uuid, CharacteristicUuid: c.Uuid, Peripheral: *p, Data: data, IsNotification: isNotification})
					break
				}
			}
		}
	}
}

// send a message to Blued
func (ble *BLE) sendCBMsg(id int, args xpc.Dict) {
	message := xpc.Dict{"kCBMsgId": id, "kCBMsgArgs": args}
	if ble.verbose {
		log.Printf("sendCBMsg %#v\n", message)
	}

	ble.conn.Send(xpc.Dict{"kCBMsgId": id, "kCBMsgArgs": args}, ble.verbose)
}

// initialize BLE
func (ble *BLE) Init() {
	ble.sendCBMsg(1, xpc.Dict{"kCBMsgArgName": fmt.Sprintf("goble-%v", time.Now().Unix()),
		"kCBMsgArgOptions": xpc.Dict{"kCBInitOptionShowPowerAlert": 0}, "kCBMsgArgType": 0})
}

// start advertising
func (ble *BLE) StartAdvertising(name string, serviceUuids []xpc.UUID) {
	uuids := make([][]byte, len(serviceUuids))
	for i, uuid := range serviceUuids {
		uuids[i] = []byte(uuid[:])
	}
	ble.sendCBMsg(8, xpc.Dict{"kCBAdvDataLocalName": name, "kCBAdvDataServiceUUIDs": uuids})
}

// start advertising as IBeacon (raw data)
func (ble *BLE) StartAdvertisingIBeaconData(data []byte) {
	var utsname xpc.Utsname
	xpc.Uname(&utsname)

	if utsname.Release >= "14." {
		l := len(data)
		buf := bytes.NewBuffer([]byte{byte(l + 5), 0xFF, 0x4C, 0x00, 0x02, byte(l)})
		buf.Write(data)
		ble.sendCBMsg(8, xpc.Dict{"kCBAdvDataAppleMfgData": buf.Bytes()})
	} else {
		ble.sendCBMsg(8, xpc.Dict{"kCBAdvDataAppleBeaconKey": data})
	}
}

// start advertising as IBeacon
func (ble *BLE) StartAdvertisingIBeacon(uuid xpc.UUID, major, minor uint16, measuredPower int8) {
	var buf bytes.Buffer
	binary.Write(&buf, binary.BigEndian, uuid[:])
	binary.Write(&buf, binary.BigEndian, major)
	binary.Write(&buf, binary.BigEndian, minor)
	binary.Write(&buf, binary.BigEndian, measuredPower)

	ble.StartAdvertisingIBeaconData(buf.Bytes())
}

// stop advertising
func (ble *BLE) StopAdvertising() {
	ble.sendCBMsg(9, nil)
}

// start scanning
func (ble *BLE) StartScanning(serviceUuids []xpc.UUID, allowDuplicates bool) {
	uuids := []string{}

	for _, uuid := range serviceUuids {
		uuids = append(uuids, uuid.String())
	}

	args := xpc.Dict{"kCBMsgArgUUIDs": uuids}
	if allowDuplicates {
		args["kCBMsgArgOptions"] = xpc.Dict{"kCBScanOptionAllowDuplicates": 1}
	} else {
		args["kCBMsgArgOptions"] = xpc.Dict{}
	}

	ble.allowDuplicates = allowDuplicates
	ble.sendCBMsg(29, args)
}

// stop scanning
func (ble *BLE) StopScanning() {
	ble.sendCBMsg(30, nil)
}

// connect
func (ble *BLE) Connect(deviceUuid xpc.UUID) {
	uuid := deviceUuid.String()
	if p, ok := ble.peripherals[uuid]; ok {
		ble.sendCBMsg(31, xpc.Dict{"kCBMsgArgOptions": xpc.Dict{"kCBConnectOptionNotifyOnDisconnection": 1}, "kCBMsgArgDeviceUUID": p.Uuid})
	} else {
		log.Println("no peripheral", deviceUuid)
	}
}

// disconnect
func (ble *BLE) Disconnect(deviceUuid xpc.UUID) {
	uuid := deviceUuid.String()
	if p, ok := ble.peripherals[uuid]; ok {
		ble.sendCBMsg(32, xpc.Dict{"kCBMsgArgDeviceUUID": p.Uuid})
	} else {
		log.Println("no peripheral", deviceUuid)
	}
}

// update rssi
func (ble *BLE) UpdateRssi(deviceUuid xpc.UUID) {
	uuid := deviceUuid.String()
	if p, ok := ble.peripherals[uuid]; ok {
		ble.sendCBMsg(43, xpc.Dict{"kCBMsgArgDeviceUUID": p.Uuid})
	} else {
		log.Println("no peripheral", deviceUuid)
	}
}

// discover services
func (ble *BLE) DiscoverServices(deviceUuid xpc.UUID, uuids []xpc.UUID) {
	sUuid := deviceUuid.String()
	if p, ok := ble.peripherals[sUuid]; ok {
		sUuids := make([]string, len(uuids))
		for i, uuid := range uuids {
			sUuids[i] = uuid.String() // uuids may be a list of []byte (2 bytes)
		}
		ble.sendCBMsg(44, xpc.Dict{"kCBMsgArgDeviceUUID": p.Uuid, "kCBMsgArgUUIDs": sUuids})
	} else {
		log.Println("no peripheral", deviceUuid)
	}
}

// discover characteristics
func (ble *BLE) DiscoverCharacterstics(deviceUuid xpc.UUID, serviceUuid string, characteristicUuids []string) {
	sUuid := deviceUuid.String()
	if p, ok := ble.peripherals[sUuid]; ok {
		cUuids := make([]string, len(characteristicUuids))
		for i, cuuid := range characteristicUuids {
			cUuids[i] = cuuid // characteristicUuids may be a list of []byte (2 bytes)
		}

		ble.sendCBMsg(61, xpc.Dict{
			"kCBMsgArgDeviceUUID":         p.Uuid,
			"kCBMsgArgServiceStartHandle": p.Services[serviceUuid].startHandle,
			"kCBMsgArgServiceEndHandle":   p.Services[serviceUuid].endHandle,
			"kCBMsgArgUUIDs":              cUuids,
		})

	} else {
		log.Println("no peripheral", deviceUuid)
	}
}

// discover descriptors
func (ble *BLE) DiscoverDescriptors(deviceUuid xpc.UUID, serviceUuid, characteristicUuid string) {
	sUuid := deviceUuid.String()
	if p, ok := ble.peripherals[sUuid]; ok {
		s := p.Services[serviceUuid]
		c := s.Characteristics[characteristicUuid]

		ble.sendCBMsg(69, xpc.Dict{
			"kCBMsgArgDeviceUUID":                p.Uuid,
			"kCBMsgArgCharacteristicHandle":      c.Handle,
			"kCBMsgArgCharacteristicValueHandle": c.ValueHandle,
		})
	} else {
		log.Println("no peripheral", deviceUuid)
	}
}

// read
func (ble *BLE) Read(deviceUuid xpc.UUID, serviceUuid, characteristicUuid string) {
	sUuid := deviceUuid.String()
	if p, ok := ble.peripherals[sUuid]; ok {
		s := p.Services[serviceUuid]
		c := s.Characteristics[characteristicUuid]

		ble.sendCBMsg(64, xpc.Dict{
			"kCBMsgArgDeviceUUID":                p.Uuid,
			"kCBMsgArgCharacteristicHandle":      c.Handle,
			"kCBMsgArgCharacteristicValueHandle": c.ValueHandle,
		})
	} else {
		log.Println("no peripheral", deviceUuid)
	}
}

// remove all services
func (ble *BLE) RemoveServices() {
	ble.sendCBMsg(12, nil)
}

// set services
func (ble *BLE) SetServices(services []Service) {
	ble.sendCBMsg(12, nil) // remove all services
	ble.attributes = xpc.Array{nil}

	attributeId := 1

	for _, service := range services {
		arg := xpc.Dict{
			"kCBMsgArgAttributeID":     attributeId,
			"kCBMsgArgAttributeIDs":    []int{},
			"kCBMsgArgCharacteristics": nil,
			"kCBMsgArgType":            1, // 1 => primary, 0 => excluded
			"kCBMsgArgUUID":            service.uuid.String(),
		}

		ble.attributes = append(ble.attributes, service)
		ble.lastServiceAttributeId = attributeId
		attributeId += 1

		characteristics := xpc.Array{}

		for _, characteristic := range service.characteristics {
			properties := 0
			permissions := 0

			if Read&characteristic.properties != 0 {
				properties |= 0x02

				if Read&characteristic.secure != 0 {
					permissions |= 0x04
				} else {
					permissions |= 0x01
				}
			}

			if WriteWithoutResponse&characteristic.properties != 0 {
				properties |= 0x04

				if WriteWithoutResponse&characteristic.secure != 0 {
					permissions |= 0x08
				} else {
					permissions |= 0x02
				}
			}

			if Write&characteristic.properties != 0 {
				properties |= 0x08

				if WriteWithoutResponse&characteristic.secure != 0 {
					permissions |= 0x08
				} else {
					permissions |= 0x02
				}
			}

			if Notify&characteristic.properties != 0 {
				if Notify&characteristic.secure != 0 {
					properties |= 0x100
				} else {
					properties |= 0x10
				}
			}

			if Indicate&characteristic.properties != 0 {
				if Indicate&characteristic.secure != 0 {
					properties |= 0x200
				} else {
					properties |= 0x20
				}
			}

			descriptors := xpc.Array{}
			for _, descriptor := range characteristic.descriptors {
				descriptors = append(descriptors, xpc.Dict{"kCBMsgArgData": descriptor.value, "kCBMsgArgUUID": descriptor.uuid.String()})
			}

			characteristicArg := xpc.Dict{
				"kCBMsgArgAttributeID":              attributeId,
				"kCBMsgArgAttributePermissions":     permissions,
				"kCBMsgArgCharacteristicProperties": properties,
				"kCBMsgArgData":                     characteristic.value,
				"kCBMsgArgDescriptors":              descriptors,
				"kCBMsgArgUUID":                     characteristic.uuid.String(),
			}

			ble.attributes = append(ble.attributes, characteristic)
			characteristics = append(characteristics, characteristicArg)

			attributeId += 1
		}

		arg["kCBMsgArgCharacteristics"] = characteristics
		ble.sendCBMsg(10, arg) // remove all services
	}
}