// Start starts the MakeyButtonDriver and polls the state of the button at the given interval.
//
// Emits the Events:
// 	Push int - On button push
//	Release int - On button release
//	Error error - On button error
func (b *MakeyButtonDriver) Start() (errs []error) {
	state := 1
	go func() {
		for {
			newValue, err := b.connection.DigitalRead(b.Pin())
			if err != nil {
				gobot.Publish(b.Event(Error), err)
			} else if newValue != state && newValue != -1 {
				state = newValue
				if newValue == 0 {
					b.Active = true
					gobot.Publish(b.Event(Push), newValue)
				} else {
					b.Active = false
					gobot.Publish(b.Event(Release), newValue)
				}
			}
			select {
			case <-time.After(b.interval):
			case <-b.halt:
				return
			}
		}
	}()
	return
}

// Start starts the GroveTemperatureSensorDriver and reads the Sensor at the given interval.
// Emits the Events:
//	Data int - Event is emitted on change and represents the current temperature in celsius from the sensor.
//	Error error - Event is emitted on error reading from the sensor.
func (a *GroveTemperatureSensorDriver) Start() (errs []error) {
	thermistor := 3975.0
	a.temperature = 0

	go func() {
		for {
			rawValue, err := a.Read()

			resistance := float64(1023.0-rawValue) * 10000 / float64(rawValue)
			newValue := 1/(math.Log(resistance/10000.0)/thermistor+1/298.15) - 273.15

			if err != nil {
				gobot.Publish(a.Event(Error), err)
			} else if newValue != a.temperature && newValue != -1 {
				a.temperature = newValue
				gobot.Publish(a.Event(Data), a.temperature)
			}
			select {
			case <-time.After(a.interval):
			case <-a.halt:
				return
			}
		}
	}()
	return
}

// TODO better pause and toogle handling
func (gpsd *GpsdDriver) Start() (errs []error) {

	gpsd.w.GpsdWrite(START)
	go func() {
		var tpv gpsdjson.TPV

		for {
			if line, err := gpsd.r.GpsdRead(); err == nil {
				json.Unmarshal([]byte(line), &tpv)
				if tpv.Class == TPV {
					gobot.Publish(gpsd.Event(TPV), tpv)
				}
			} else {
				log.Println("Error reading on gpsd socket", err.Error())
				gobot.Publish(gpsd.Event(ERROR), err)
				return
			}
			select {
			case <-time.After(gpsd.interval):
			case <-gpsd.halt:
				return
			}
		}
	}()
	return nil
}

// HandleEvent publishes an specific event according to data received
func (j *JoystickDriver) handleEvent(event sdl.Event) error {
	switch data := event.(type) {
	case *sdl.JoyAxisEvent:
		if data.Which == j.adaptor().joystick.InstanceID() {
			axis := j.findName(data.Axis, j.config.Axis)
			if axis == "" {
				return fmt.Errorf("Unknown Axis: %v", data.Axis)
			}
			gobot.Publish(j.Event(axis), data.Value)
		}
	case *sdl.JoyButtonEvent:
		if data.Which == j.adaptor().joystick.InstanceID() {
			button := j.findName(data.Button, j.config.Buttons)
			if button == "" {
				return fmt.Errorf("Unknown Button: %v", data.Button)
			}
			if data.State == 1 {
				gobot.Publish(j.Event(fmt.Sprintf("%s_press", button)), nil)
			}
			gobot.Publish(j.Event(fmt.Sprintf("%s_release", button)), nil)
		}
	case *sdl.JoyHatEvent:
		if data.Which == j.adaptor().joystick.InstanceID() {
			hat := j.findHatName(data.Value, data.Hat, j.config.Hats)
			if hat == "" {
				return fmt.Errorf("Unknown Hat: %v %v", data.Hat, data.Value)
			}
			gobot.Publish(j.Event(hat), true)
		}
	}
	return nil
}

func (b *BLEMinidroneDriver) Init() (err error) {
	b.GenerateAllStates()

	// subscribe to battery notifications
	b.adaptor().Subscribe(DroneNotificationService, BatteryCharacteristic, func(data []byte, e error) {
		gobot.Publish(b.Event(Battery), data[len(data)-1])
	})

	// subscribe to flying status notifications
	b.adaptor().Subscribe(DroneNotificationService, FlightStatusCharacteristic, func(data []byte, e error) {
		if len(data) < 7 || data[2] != 2 {
			fmt.Println(data)
			return
		}
		gobot.Publish(b.Event(Status), data[6])
		if (data[6] == 1 || data[6] == 2) && !b.flying {
			b.flying = true
			gobot.Publish(b.Event(Flying), true)
		} else if (data[6] == 0) && b.flying {
			b.flying = false
			gobot.Publish(b.Event(Landed), true)
		}
	})

	return
}

// Start inits leap motion driver by enabling gestures
// and listening from incoming messages.
//
// Publishes the following events:
//		"message" - Emits Frame on new message received from Leap.
//		"hand" - Emits Hand when detected in message from Leap.
//		"gesture" - Emits Gesture when detected in message from Leap.
func (l *LeapMotionDriver) Start() (errs []error) {
	enableGestures := map[string]bool{"enableGestures": true}
	b, err := json.Marshal(enableGestures)
	if err != nil {
		return []error{err}
	}
	_, err = l.adaptor().ws.Write(b)
	if err != nil {
		return []error{err}
	}

	go func() {
		var msg []byte
		var frame Frame
		for {
			receive(l.adaptor().ws, &msg)
			frame = l.ParseFrame(msg)
			gobot.Publish(l.Event("message"), frame)

			for _, hand := range frame.Hands {
				gobot.Publish(l.Event("hand"), hand)
			}

			for _, gesture := range frame.Gestures {
				gobot.Publish(l.Event("gesture"), gesture)
			}
		}
	}()

	return
}

// Start writes initialization bytes and reads from adaptor
// using specified interval to accelerometer andtemperature data
func (h *MPU6050Driver) Start() (errs []error) {
	if err := h.initialize(); err != nil {
		return []error{err}
	}

	go func() {
		for {
			if err := h.connection.I2cWrite(mpu6050Address, []byte{MPU6050_RA_ACCEL_XOUT_H}); err != nil {
				gobot.Publish(h.Event(Error), err)
				continue
			}

			ret, err := h.connection.I2cRead(mpu6050Address, 14)
			if err != nil {
				gobot.Publish(h.Event(Error), err)
				continue
			}
			buf := bytes.NewBuffer(ret)
			binary.Read(buf, binary.BigEndian, &h.Accelerometer)
			binary.Read(buf, binary.BigEndian, &h.Gyroscope)
			binary.Read(buf, binary.BigEndian, &h.Temperature)
			<-time.After(h.interval)
		}
	}()
	return
}

// Start initilizes i2c and reads from adaptor
// using specified interval to update with new value
func (w *WiichuckDriver) Start() (errs []error) {
	if err := w.connection.I2cStart(0x52); err != nil {
		return []error{err}
	}

	go func() {
		for {
			if err := w.connection.I2cWrite([]byte{0x40, 0x00}); err != nil {
				gobot.Publish(w.Event(Error), err)
				continue
			}
			if err := w.connection.I2cWrite([]byte{0x00}); err != nil {
				gobot.Publish(w.Event(Error), err)
				continue
			}
			newValue, err := w.connection.I2cRead(6)
			if err != nil {
				gobot.Publish(w.Event(Error), err)
				continue
			}
			if len(newValue) == 6 {
				if err = w.update(newValue); err != nil {
					gobot.Publish(w.Event(Error), err)
					continue
				}
			}
			<-time.After(w.interval)
		}
	}()
	return
}

func ExampleOn() {
	e := gobot.NewEvent()
	gobot.On(e, func(s interface{}) {
		fmt.Println(s)
	})
	gobot.Publish(e, 100)
	gobot.Publish(e, 200)
}

// updateButtons publishes "c" and "x" events if present in data
func (w *WiichuckDriver) updateButtons() {
	if w.data["c"] == 0 {
		gobot.Publish(w.Event(C), true)
	}
	if w.data["z"] == 0 {
		gobot.Publish(w.Event(Z), true)
	}
}

func (b *ButtonDriver) update(newValue int) {
	if newValue == 1 {
		b.Active = true
		gobot.Publish(b.Event(Push), newValue)
	} else {
		b.Active = false
		gobot.Publish(b.Event(Release), newValue)
	}
}

func (m *MakeyButtonDriver) update(newVal int) {
	if newVal == 0 {
		m.Active = true
		gobot.Publish(m.Events["push"], newVal)
	} else {
		m.Active = false
		gobot.Publish(m.Events["release"], newVal)
	}
}

func ExampleOnce() {
	e := gobot.NewEvent()
	gobot.Once(e, func(s interface{}) {
		fmt.Println(s)
		fmt.Println("I will no longer respond to events")
	})
	gobot.Publish(e, 100)
	gobot.Publish(e, 200)
}

func (b *ButtonDriver) update(newVal int) {
	if newVal == 1 {
		b.Active = true
		gobot.Publish(b.Event("push"), newVal)
	} else {
		b.Active = false
		gobot.Publish(b.Event("release"), newVal)
	}
}

// Start inits leap motion driver by enabling gestures
// and listening from incoming messages.
//
// Publishes the following events:
//		"message" - Emits Frame on new message received from Leap.
func (l *LeapMotionDriver) Start() (errs []error) {
	enableGestures := map[string]bool{
		"enableGestures": true,
		"background":     true,
		"optimizeHMD":    true,
	}
	b, err := json.Marshal(enableGestures)
	if err != nil {
		return []error{err}
	}
	_, err = l.adaptor().ws.Write(b)
	if err != nil {
		return []error{err}
	}

	go func() {
		var msg []byte
		for {
			receive(l.adaptor().ws, &msg)
			gobot.Publish(l.Event("message"), l.ParseFrame(msg))
		}
	}()

	return
}

func NewJenkinsconnectDriver(a *JenkinsconnectAdaptor, name string) *JenkinsconnectDriver {
	j := &JenkinsconnectDriver{
		name:       name,
		connection: a,
		Eventer:    gobot.NewEventer(),
		Commander:  gobot.NewCommander(),
	}

	j.AddEvent(JobResult)

	j.AddCommand("ParseResults", func(params map[string]interface{}) interface{} {
		var snapshot JobOutcomeSnapshot

		result := ParseJobState(params)
		if (JobOutcome{}) != result {
			fmt.Printf("Result: %v\n", result)
			lastOutcome, ok := jobStates[result.Name]
			if ok {
				fmt.Printf("Last outcome: %v\n", lastOutcome)
			}

			snapshot.Outcome = result
			snapshot.RanAt = time.Now()
			jobStates[result.Name] = snapshot
			gobot.Publish(j.Event(JobResult), result)
		}

		return result
	})

	return j
}

// Start starts the SpheroDriver and enables Collision Detection.
// Returns true on successful start.
//
// Emits the Events:
// 	Collision  sphero.CollisionPacket - On Collision Detected
// 	SensorData sphero.DataStreamingPacket - On Data Streaming event
// 	Error      error- On error while processing asynchronous response
func (s *SpheroDriver) Start() (errs []error) {
	go func() {
		for {
			packet := <-s.packetChannel
			err := s.write(packet)
			if err != nil {
				gobot.Publish(s.Event(Error), err)
			}
		}
	}()

	go func() {
		for {
			response := <-s.responseChannel
			s.syncResponse = append(s.syncResponse, response)
		}
	}()

	go func() {
		for {
			header := s.readHeader()
			if header != nil && len(header) != 0 {
				body := s.readBody(header[4])
				data := append(header, body...)
				checksum := data[len(data)-1]
				if checksum != calculateChecksum(data[2:len(data)-1]) {
					continue
				}
				switch header[1] {
				case 0xFE:
					s.asyncResponse = append(s.asyncResponse, data)
				case 0xFF:
					s.responseChannel <- data
				}
			}
		}
	}()

	go func() {
		for {
			var evt []uint8
			for len(s.asyncResponse) != 0 {
				evt, s.asyncResponse = s.asyncResponse[len(s.asyncResponse)-1], s.asyncResponse[:len(s.asyncResponse)-1]
				if evt[2] == 0x07 {
					s.handleCollisionDetected(evt)
				} else if evt[2] == 0x03 {
					s.handleDataStreaming(evt)
				}
			}
			time.Sleep(100 * time.Millisecond)
		}
	}()

	s.ConfigureCollisionDetection(DefaultCollisionConfig())
	s.enableStopOnDisconnect()

	return
}

func (n *NeuroskyDriver) parsePacket(data []byte) {
	buf := bytes.NewBuffer(data)
	for buf.Len() > 0 {
		b, _ := buf.ReadByte()
		switch b {
		case CodeEx:
			gobot.Publish(n.Events["Extended"], nil)
		case CodeSignalQuality:
			ret, _ := buf.ReadByte()
			gobot.Publish(n.Events["Signal"], ret)
		case CodeAttention:
			ret, _ := buf.ReadByte()
			gobot.Publish(n.Events["Attention"], ret)
		case CodeMeditation:
			ret, _ := buf.ReadByte()
			gobot.Publish(n.Events["Meditation"], ret)
		case CodeBlink:
			ret, _ := buf.ReadByte()
			gobot.Publish(n.Events["Blink"], ret)
		case CodeWave:
			buf.Next(1)
			var ret = make([]byte, 2)
			buf.Read(ret)
			gobot.Publish(n.Events["Wave"], ret)
		case CodeAsicEEG:
			var ret = make([]byte, 25)
			i, _ := buf.Read(ret)
			if i == 25 {
				gobot.Publish(n.Events["EEG"], n.parseEEG(ret))
			}
		}
	}
}

// parsePacket publishes event according to data parsed
func (n *NeuroskyDriver) parsePacket(buf *bytes.Buffer) {
	for buf.Len() > 0 {
		b, _ := buf.ReadByte()
		switch b {
		case CodeEx:
			gobot.Publish(n.Event("extended"), nil)
		case CodeSignalQuality:
			ret, _ := buf.ReadByte()
			gobot.Publish(n.Event("signal"), ret)
		case CodeAttention:
			ret, _ := buf.ReadByte()
			gobot.Publish(n.Event("attention"), ret)
		case CodeMeditation:
			ret, _ := buf.ReadByte()
			gobot.Publish(n.Event("meditation"), ret)
		case CodeBlink:
			ret, _ := buf.ReadByte()
			gobot.Publish(n.Event("blink"), ret)
		case CodeWave:
			buf.Next(1)
			var ret = make([]byte, 2)
			buf.Read(ret)
			gobot.Publish(n.Event("wave"), int16(ret[0])<<8|int16(ret[1]))
		case CodeAsicEEG:
			ret := make([]byte, 25)
			i, _ := buf.Read(ret)
			if i == 25 {
				gobot.Publish(n.Event("eeg"), n.parseEEG(ret))
			}
		}
	}
}

// Start writes initialization bytes and reads from adaptor
// using specified interval to accelerometer andtemperature data
func (h *MPL115A2Driver) Start() (errs []error) {
	var temperature uint16
	var pressure uint16
	var pressureComp float32

	if err := h.initialization(); err != nil {
		return []error{err}
	}

	go func() {
		for {
			if err := h.connection.I2cWrite(mpl115a2Address, []byte{MPL115A2_REGISTER_STARTCONVERSION, 0}); err != nil {
				gobot.Publish(h.Event(Error), err)
				continue

			}
			<-time.After(5 * time.Millisecond)

			if err := h.connection.I2cWrite(mpl115a2Address, []byte{MPL115A2_REGISTER_PRESSURE_MSB}); err != nil {
				gobot.Publish(h.Event(Error), err)
				continue
			}

			ret, err := h.connection.I2cRead(mpl115a2Address, 4)
			if err != nil {
				gobot.Publish(h.Event(Error), err)
				continue
			}
			if len(ret) == 4 {
				buf := bytes.NewBuffer(ret)
				binary.Read(buf, binary.BigEndian, &pressure)
				binary.Read(buf, binary.BigEndian, &temperature)

				temperature = temperature >> 6
				pressure = pressure >> 6

				pressureComp = float32(h.A0) + (float32(h.B1)+float32(h.C12)*float32(temperature))*float32(pressure) + float32(h.B2)*float32(temperature)
				h.Pressure = (65.0/1023.0)*pressureComp + 50.0
				h.Temperature = ((float32(temperature) - 498.0) / -5.35) + 25.0
			}
			<-time.After(h.interval)
		}
	}()
	return
}