/*
Forward message to MQTT server
*/
func ConnectToMQTTServer(MQTTServerAddress string) (*client.Client, error) {
	defer func() {
		if err := recover(); err != nil {
			utils.Log.Println(err)
			debug.PrintStack()
		}
	}()

	cli := client.New(&client.Options{
		ErrorHandler: func(err error) {
			utils.Log.Println("MQTT Client error:", err)
		},
	})

	var err error

	RandomID := utils.MakeRandomID()

	err = cli.Connect(&client.ConnectOptions{
		Network:         "tcp",
		Address:         MQTTServerAddress,
		ClientID:        []byte(RandomID),
		CleanSession:    true,
		PINGRESPTimeout: 5 * time.Second,
		KeepAlive:       5,
	})

	if err != nil {
		return nil, err
	}

	return cli, nil
}

func newMqttEngine() (*mqttEngine, error) {

	murl, err := url.Parse(*mqttURL)

	if err != nil {
		return nil, err
	}

	mq := &mqttEngine{}

	// Create an MQTT Client.
	cli := client.New(&client.Options{
		ErrorHandler: mq.handleClientError,
	})

	mq.murl = murl
	mq.cli = cli

	mq.attemptConnect()

	//mq.publisher = publisher
	mq.pollTicker = time.NewTicker(time.Second * 1)
	mq.pubTicker = time.NewTicker(time.Second * 15)

	go poll(mq)
	go publish(mq, "Ready to publish")

	return mq, nil
}

func Test_newCommandConn_ReadFileErr(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	if _, err := newCommandConn([]string{"-crt", "not_exist_file.crt"}, cli); err == nil {
		notNilErrorExpected(t)
	}
}

func Test_newCommandConn(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	if _, err := newCommandConn([]string{"-crt", filepath.Join("test", "test.crt")}, cli); err != nil {
		nilErrorExpected(t, err)
	}
}

func Test_newCommandPub_errCmdArgsParse(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	if _, err := newCommandPub([]string{"-not-exist-flag"}, cli); err != errCmdArgsParse {
		invalidError(t, err, errCmdArgsParse)
	}
}

func Test_newCommandPub(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	if _, err := newCommandPub([]string{"-t", "topicName"}, cli); err != nil {
		nilErrorExpected(t, err)
	}
}

func Test_newCommand_errInvalidCmdName(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	if _, err := newCommand("invalidCmdName", nil, cli); err != errInvalidCmdName {
		invalidError(t, err, errInvalidCmdName)
	}
}

func Test_newCommandDisconn(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	if cmd := newCommandDisconn(cli); cmd == nil {
		t.Error("cmd => nil, want => not nil")
	}
}

func Test_newCommandConn_errParseCrtFailure(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	if _, err := newCommandConn([]string{"-crt", filepath.Join("test", "error.crt")}, cli); err != errParseCrtFailure {
		invalidError(t, err, errParseCrtFailure)
	}
}

func main() {
	// Set up channel on which to send signal notifications.
	sigc := make(chan os.Signal, 1)
	signal.Notify(sigc, os.Interrupt, os.Kill)

	// Print the version of GMQ Client and exit if "v" flag is true.
	if *flagV {
		printVersion()
		exit(0)
		return
	}

	// Create a Client.
	cli := client.New(&client.Options{
		ErrorHandler: errorHandler,
	})

	// Quit if signal notifications are sent.
	go func() {
		<-sigc
		quit(cli)
	}()

	// Create a scanner which reads lines from standard input.
	scanner := bufio.NewScanner(stdin)

	for printHeader(); scanner.Scan(); printHeader() {
		// Get the command name and the command arguments from
		// the scanner.
		cmdName, cmdArgs := cmdNameArgs(scanner.Text())

		// Skip the remaining processes if the command name is zero value.
		if cmdName == "" {
			continue
		}

		// Create a command.
		cmd, err := newCommand(cmdName, cmdArgs, cli)
		if err != nil {
			printError(err)
			continue
		}

		// Run the command.
		if err := cmd.run(); err != nil {
			printError(err)
			continue
		}

		// Print the successfule message.
		printSuccess(cmdName)
	}
}

func Test_commandDisconn_run(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	cmd := &commandDisconn{cli: cli}

	if err := cmd.run(); err != client.ErrNotYetConnected {
		invalidError(t, err, client.ErrNotYetConnected)
	}
}

func Test_commandQuit_run(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	cmd := commandQuit{
		cli: cli,
	}

	if err := cmd.run(); err != nil {
		nilErrorExpected(t, err)
	}
}

func Test_commandPub_run(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	cmd, err := newCommandPub([]string{"-t", "topicName"}, cli)
	if err != nil {
		nilErrorExpected(t, err)
	}

	if err := cmd.run(); err != client.ErrNotYetConnected {
		invalidError(t, err, client.ErrNotYetConnected)
	}
}

func Test_quit(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	err := cli.Connect(&client.ConnectOptions{
		Network:  "tcp",
		Address:  testAddress,
		ClientID: []byte("clientID"),
	})
	if err != nil {
		nilErrorExpected(t, err)
	}

	quit(cli)
}

func Test_commandConn_run(t *testing.T) {
	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	cmd, err := newCommandConn(nil, cli)
	if err != nil {
		nilErrorExpected(t, err)
		return
	}

	if err := cmd.run(); err == nil {
		notNilErrorExpected(t)
	}
}

func NewChat() (*Chat, error) {
	cli := client.New(&client.Options{
		ErrorHandler: func(err error) {
			log.Println(err)
		},
	})
	chat := Chat{MqttClient: cli, Rooms: make(map[string]*Room)}

	u, _ := uuid.NewV4()
	err := cli.Connect(&client.ConnectOptions{
		Network:  "tcp",
		Address:  getMqttMaster() + ":1883",
		ClientID: []byte(u.String()),
	})
	if err != nil {
		return nil, err
	}

	err = cli.Subscribe(&client.SubscribeOptions{
		SubReqs: []*client.SubReq{
			&client.SubReq{
				TopicFilter: []byte("rooms/#"),
				QoS:         mqtt.QoS0,
				Handler: func(topicName, message []byte) {
					s := strings.Split(string(topicName), "/")
					if len(s) < 2 {
						log.Printf("Unexpected topic: %s", string(topicName))
						return
					}
					room := chat.GetRoom(s[1])
					var msg Message
					json.Unmarshal(message, &msg)
					for e := room.Channels.Front(); e != nil; e = e.Next() {
						ch := e.Value.(chan Message)
						ch <- msg
					}
				},
			},
		},
	})
	if err != nil {
		panic(err)
	}
	return &chat, nil
}

func Test_newCommand(t *testing.T) {
	cmdNames := []string{
		cmdNameConn,
		cmdNameDisconn,
		cmdNameHelp,
		cmdNamePub,
		cmdNameQuit,
		cmdNameSub,
		cmdNameUnsub,
	}

	cli := client.New(&client.Options{
		ErrorHandler: func(_ error) {},
	})

	defer quit(cli)

	for _, cmdName := range cmdNames {
		if _, err := newCommand(cmdName, nil, cli); err != nil {
			nilErrorExpected(t, err)
		}
	}
}

func main() {
	r := gin.New()
	r.Use(gin.Recovery())

	r.GET("/ping", func(c *gin.Context) {
		c.JSON(200, gin.H{
			"message":  "pong",
			"lastseen": time.Now().String(),
		})
	})

	r.GET("/fgdata", func(c *gin.Context) {

		datamux.Lock()
		if fgdata != "" && strings.Contains(fgdata, "#") {
			s := strings.Split(fgdata, "#")

			curdata.Message = "OK"
			curdata.Lastseen = lastseen
			curdata.Lux = s[1]
			curdata.Temp = s[2]
			curdata.Lstate = s[0]
		}

		if light1 != "" {
			curdata.Light1 = light1
			curdata.Light1ls = light1ls
		} else {
			curdata.Light1 = "N/A"
			curdata.Light1ls = light1ls
		}
		datamux.Unlock()

		if fgdata != "" && strings.Contains(fgdata, "#") {
			//s := strings.Split(fgdata, "#")
			c.JSON(200, curdata)
			// c.JSON(200, gin.H{
			// 	"message":  "OK",
			// 	"lastseen": lastseen,
			// 	"lux":      s[1],
			// 	"temp":     s[2],
			// 	"lstate":   s[0],
			//})
		} else {
			c.JSON(200, gin.H{
				"message": "No data retreived. Check Network Connection",
			})
		}
	})

	r.GET("/", func(c *gin.Context) {
		c.Redirect(http.StatusMovedPermanently, "/static")
	})

	r.StaticFS("/static", http.Dir("./web"))

	//MQTT

	// Create an MQTT Client.
	cli := client.New(&client.Options{
		// Define the processing of the error handler.
		ErrorHandler: func(err error) {
			fmt.Println(err)
		},
	})

	// Terminate the Client.
	defer cli.Terminate()

	defer cli.Disconnect()

	// Connect to the MQTT Server.
	err := cli.Connect(&client.ConnectOptions{
		Network:  "tcp",
		Address:  "192.168.2.37:1883",
		ClientID: []byte("example-client"),
	})
	if err != nil {
		fmt.Println("Error on mqtt connect:", err)
		os.Exit(1)
	}

	go mqttWorker(cli)

	r.Run() // listen and server on 0.0.0.0:8080
}

func main() {
	flag.Parse()

	if flag.NFlag() < 2 {
		fmt.Println("Too few arguments")
		Usage()
		os.Exit(0)
	}
	if (*message == "") || (*topic == "") {
		fmt.Println("Need a topic and message to publish")
		Usage()
		os.Exit(0)
	}

	fmt.Println("topic: ", *topic, "\tmessage: ", *message)

	// Set up channel on which to send signal notifications.
	sigc := make(chan os.Signal, 1)
	signal.Notify(sigc, os.Interrupt, os.Kill)

	// Create an MQTT Client.
	cli := client.New(&client.Options{
		// Define the processing of the error handler.
		ErrorHandler: func(err error) {
			fmt.Println(err)
		},
	})

	// Terminate the Client.
	defer cli.Terminate()

	s := []string{*host, *port}

	address := strings.Join(s, ":")
	fmt.Println("host info: ", address, "QoS option: ", *qos)

	var mQoS = mqtt.QoS0
	switch *qos {
	case "0":
		mQoS = mqtt.QoS0
	case "1":
		mQoS = mqtt.QoS1
	case "2":
		mQoS = mqtt.QoS2
	default:
		mQoS = mqtt.QoS0
	}

	// Connect to the MQTT Server.
	err := cli.Connect(&client.ConnectOptions{
		Network:  "tcp",
		Address:  address,
		ClientID: []byte("example-client"),
		//	CONNACKTimeout:  30,
		//	KeepAlive:       50,
	})
	if err != nil {
		panic(err)
	}

	err = cli.Publish(&client.PublishOptions{
		QoS:       mQoS,
		TopicName: []byte(*topic),
		Message:   []byte(*message),
	})
	if err != nil {
		panic(err)
	}

	// Wait for receiving a signal.
	// I cannot figure out why publish does not work without this command
	// <-sigc
	time.Sleep(time.Duration(*delay) * time.Millisecond)

	// Disconnect the Network Connection.
	if err := cli.Disconnect(); err != nil {
		panic(err)
	}
}