package api

import (
	"encoding/json"
	"log"
	"net/http"
	"strconv"
	"strings"
	"time"

	"github.com/gorilla/mux"

	"github.com/leandrofars/oktopus/internal/db"
	usp_msg "github.com/leandrofars/oktopus/internal/usp_message"
	"github.com/leandrofars/oktopus/internal/utils"
	"google.golang.org/protobuf/proto"
)

type WiFi struct {
	SSID                 string   `json:"ssid"`
	Password             string   `json:"password"`
	Security             string   `json:"security"`
	SecurityCapabilities []string `json:"securityCapabilities"`
	AutoChannelEnable    bool     `json:"autoChannelEnable"`
	Channel              int      `json:"channel"`
	ChannelBandwidth     string   `json:"channelBandwidth"`
	FrequencyBand        string   `json:"frequencyBand"`
	//PossibleChannels     		[]int    `json:"PossibleChannels"`
	SupportedChannelBandwidths []string `json:"supportedChannelBandwidths"`
}

func (a *Api) deviceWifi(w http.ResponseWriter, r *http.Request) {
	vars := mux.Vars(r)
	sn := vars["sn"]
	device := a.deviceExists(sn, w)

	if r.Method == http.MethodGet {
		msg := utils.NewGetMsg(usp_msg.Get{
			ParamPaths: []string{
				"Device.WiFi.SSID.[Enable==true].SSID",
				//"Device.WiFi.AccessPoint.[Enable==true].SSIDReference",
				"Device.WiFi.AccessPoint.[Enable==true].Security.ModeEnabled",
				"Device.WiFi.AccessPoint.[Enable==true].Security.ModesSupported",
				//"Device.WiFi.EndPoint.[Enable==true].",
				"Device.WiFi.Radio.[Enable==true].AutoChannelEnable",
				"Device.WiFi.Radio.[Enable==true].Channel",
				"Device.WiFi.Radio.[Enable==true].CurrentOperatingChannelBandwidth",
				"Device.WiFi.Radio.[Enable==true].OperatingFrequencyBand",
				//"Device.WiFi.Radio.[Enable==true].PossibleChannels",
				"Device.WiFi.Radio.[Enable==true].SupportedOperatingChannelBandwidths",
			},
			MaxDepth: 2,
		})

		encodedMsg, err := proto.Marshal(&msg)
		if err != nil {
			log.Println(err)
			w.WriteHeader(http.StatusBadRequest)
			return
		}

		record := utils.NewUspRecord(encodedMsg, sn)
		tr369Message, err := proto.Marshal(&record)
		if err != nil {
			log.Fatalln("Failed to encode tr369 record:", err)
		}

		//a.Broker.Request(tr369Message, usp_msg.Header_GET, "oktopus/v1/agent/"+sn, "oktopus/v1/get/"+sn)
		a.QMutex.Lock()
		a.MsgQueue[msg.Header.MsgId] = make(chan usp_msg.Msg)
		a.QMutex.Unlock()
		log.Println("Sending Msg:", msg.Header.MsgId)

		if device.Mqtt == db.Online {
			a.Mqtt.Publish(tr369Message, "oktopus/v1/agent/"+sn, "oktopus/v1/api/"+sn, false)
		} else if device.Websockets == db.Online {
			a.Websockets.Publish(tr369Message, "", "", false)
		} else if device.Stomp == db.Online {
			//TODO: send stomp message
		}

		//TODO: verify in protocol and in other models, the Device.Wifi parameters. Maybe in the future, to use SSIDReference from AccessPoint
		select {
		case msg := <-a.MsgQueue[msg.Header.MsgId]:
			log.Printf("Received Msg: %s", msg.Header.MsgId)
			a.QMutex.Lock()
			delete(a.MsgQueue, msg.Header.MsgId)
			a.QMutex.Unlock()
			log.Println("requests queue:", a.MsgQueue)
			answer := msg.Body.GetResponse().GetGetResp()

			var wifi [2]WiFi

			//TODO: better algorithm, might use something faster an more reliable
			//TODO: full fill the commented wifi resources
			for _, x := range answer.ReqPathResults {
				if x.RequestedPath == "Device.WiFi.SSID.[Enable==true].SSID" {
					for i, y := range x.ResolvedPathResults {
						wifi[i].SSID = y.ResultParams["SSID"]
					}
					continue
				}
				if x.RequestedPath == "Device.WiFi.AccessPoint.[Enable==true].Security.ModeEnabled" {
					for i, y := range x.ResolvedPathResults {
						wifi[i].Security = y.ResultParams["Security.ModeEnabled"]
					}
					continue
				}
				if x.RequestedPath == "Device.WiFi.AccessPoint.[Enable==true].Security.ModesSupported" {
					for i, y := range x.ResolvedPathResults {
						wifi[i].SecurityCapabilities = strings.Split(y.ResultParams["Security.ModesSupported"], ",")
					}
					continue
				}
				if x.RequestedPath == "Device.WiFi.Radio.[Enable==true].AutoChannelEnable" {
					for i, y := range x.ResolvedPathResults {
						autoChannel, err := strconv.ParseBool(y.ResultParams["AutoChannelEnable"])
						if err != nil {
							log.Println(err)
							wifi[i].AutoChannelEnable = false
						} else {
							wifi[i].AutoChannelEnable = autoChannel
						}
					}
					continue
				}
				if x.RequestedPath == "Device.WiFi.Radio.[Enable==true].Channel" {
					for i, y := range x.ResolvedPathResults {
						channel, err := strconv.Atoi(y.ResultParams["Channel"])
						if err != nil {
							log.Println(err)
							wifi[i].Channel = -1
						} else {
							wifi[i].Channel = channel
						}
					}
					continue
				}
				if x.RequestedPath == "Device.WiFi.Radio.[Enable==true].CurrentOperatingChannelBandwidth" {
					for i, y := range x.ResolvedPathResults {
						wifi[i].ChannelBandwidth = y.ResultParams["CurrentOperatingChannelBandwidth"]
					}
					continue
				}
				if x.RequestedPath == "Device.WiFi.Radio.[Enable==true].OperatingFrequencyBand" {
					for i, y := range x.ResolvedPathResults {
						wifi[i].FrequencyBand = y.ResultParams["OperatingFrequencyBand"]
					}
					continue
				}
				if x.RequestedPath == "Device.WiFi.Radio.[Enable==true].SupportedOperatingChannelBandwidths" {
					for i, y := range x.ResolvedPathResults {
						wifi[i].SupportedChannelBandwidths = strings.Split(y.ResultParams["SupportedOperatingChannelBandwidths"], ",")
					}
					continue
				}
			}
			json.NewEncoder(w).Encode(&wifi)
			return
		case <-time.After(time.Second * 45):
			log.Printf("Request %s Timed Out", msg.Header.MsgId)
			w.WriteHeader(http.StatusGatewayTimeout)
			a.QMutex.Lock()
			delete(a.MsgQueue, msg.Header.MsgId)
			a.QMutex.Unlock()
			log.Println("requests queue:", a.MsgQueue)
			json.NewEncoder(w).Encode("Request Timed Out")
			return
		}
	}
}