package locative

import (
  "reflect"
  "time"
  "log"
  "encoding/json"
  "udi/config"
  "udi/handlers/handler"
  "udi/database"
)


type LocativeHandler struct {
  handler.CommonHandler
  dbh *database.DatabaseHandle
}

type locativeEvent struct {
  Trigger string `json:"trigger"`
  Device string `json:"device"`
  Location string `json:"location"`
  Latitude string `json:"latitude"`
  Longitude string `json:"longitude"`
  Person string `json:"person"`
  Timestamp string `json:"timestamp"`
}

func New(id string, config config.HandlerConfigT) handler.Handler {
  t := &LocativeHandler {
  }
  t.Id = id
  t.dbh = database.NewDatabaseHandle()
  return t
}


func (self *LocativeHandler) Handle(message handler.MessageT) {
  log.Printf("Handler Locative %d processing %s -> %s", self.Id, message.Topic, message.Payload)

  var locativeEvent locativeEvent
  err := json.Unmarshal([]byte(message.Payload), &locativeEvent)
  if err != nil {
    self.Lost("Unable to parse payload into locativeEvent struct", err, message)
    return
  }

  variables := make(map[string]database.VariableType)
  locativeEventStructValue := reflect.ValueOf(locativeEvent)
  for i := 0; i < locativeEventStructValue.NumField(); i++ {
    field := locativeEventStructValue.Type().Field(i)
    fieldValue := locativeEventStructValue.Field(i)
    v := database.VariableType {
      Label: "",
      Variable: field.Name,
      Unit: "",
      Value: fieldValue.Interface(),
    }
    variables[field.Name] = v
  }

  measurement := database.Measurement {
    Time: time.Now(),
    Application: "Locative",
    Device: locativeEvent.Person,
    Values: variables,
  }

  self.dbh.StoreMeasurement(&measurement)
  self.S()
}