cmd

var RootCmd = &cobra.Command{
	Short: "MQTT Home Controller",
	Run: func(cmd *cobra.Command, args []string) {
		var l config.LogLevel
		switch logLevel {
		case "debug":
			l = config.LogDebug
		case "info":
			l = config.LogInfo
		case "warn":
			l = config.LogWarn
		case "error":
			l = config.LogError
		case "":
		default:
			logrus.Fatal("invalid log level")
		}

		if l != config.LogLevel("") {
			cfg.LogLevel = l
		}

		if configFile != "" {
			data, err := ioutil.ReadFile(configFile)
			if err != nil {
				logrus.Fatal(err)
			}

			jsonBlob, err := yaml.YAMLToJSON(data)
			if err != nil {
				logrus.Fatal(err)
			}

			var fromFile config.Config
			if err := json.Unmarshal(jsonBlob, &fromFile); err != nil {
				logrus.Fatal(err)
			}

			cfg.Merge(&fromFile)
		}

		switch cfg.LogLevel {
		case config.LogDebug:
			logrus.SetLevel(logrus.DebugLevel)
		case config.LogInfo:
			logrus.SetLevel(logrus.InfoLevel)
		case config.LogWarn:
			logrus.SetLevel(logrus.WarnLevel)
		case config.LogError:
			logrus.SetLevel(logrus.ErrorLevel)
		}
		logger := logrus.New()
		logger.SetLevel(logrus.GetLevel())

		if listener.Address == "" && !cfg.HTTP.HasListener() {
			logrus.Debug("Using default configuration for HTTP server")
			listener = server.ListenerConfig{
				Address: "tcp://127.0.0.1:4300",
			}
		}

		if listener.Address != "" {
			cfg.HTTP.Listen = ""
			cfg.HTTP.Listeners = []server.ListenerConfig{listener}
		}

		srv, err := server.New(server.Config{
			Listeners: cfg.HTTP.ListenerConfigs(),
			Logger:    logger,
		})

		if err != nil {
			logger.Fatal(err)
		}

		m := macaron.Classic()

		store, err := registry.Open("memory", "")
		if err != nil {
			logger.Fatal(err)
		}

		render.Bind(m)

		m.MapTo(store, (*registry.Registry)(nil))

		m.Use(macaron.Renderer())

		routes.Install(m)

		opts := mqtt.NewClientOptions()
		if cfg.MQTT.Username != "" {
			opts.SetUsername(cfg.MQTT.Username)
		}

		if cfg.MQTT.Password != "" {
			opts.SetPassword(cfg.MQTT.Password)
		}

		opts.SetAutoReconnect(true).SetCleanSession(true).SetClientID(cfg.MQTT.ClientID)

		for _, broker := range cfg.MQTT.Brokers {
			opts.AddBroker(broker)
		}

		if len(opts.Servers) == 0 {
			logger.Fatal("Missing MQTT hostname")
		}

		cli := mqtt.NewClient(opts)

		if token := cli.Connect(); token.Wait() && token.Error() != nil {
			logger.Fatalf("failed to connect: %s", token.Error())
		}
		logger.Infof("Successfully connected to MQTT brokers")

		controller, err := control.New(
			control.WithLogger(logger),
			control.WithMQTTClient(cli),
			control.WithRegistry(store),
		)
		if err != nil {
			logger.Fatal(err)
		}

		m.Map(controller)

		if cfg.ThingsDir != "" {
			things, err := config.ReadThingsFromDirectory(cfg.ThingsDir)
			if err != nil {
				logger.Fatal(err)
			}

			ctx := context.Background()

			for _, t := range things {
				t.ApplyDefaults()

				if err := spec.ValidateThing(t); err != nil {
					logger.Fatal(err)
				}

				if err := store.Create(ctx, t); err != nil {
					logger.Fatal(err)
				}
			}
		}

		if err := srv.Listen(m); err != nil {
			logger.Fatal(err)
		}

		controller.Run(context.Background())
	},
}