package main

import (
	"AudioPlayer/Intercom"
	"AudioPlayer/QuectelAT"
	"AudioPlayer/VoiceCall"
	"bytes"
	"github.com/gin-gonic/gin"
	"os"
	"os/exec"
	"sync"

	"github.com/BurntSushi/toml"
)

func Command(exe string, args []string, ctx *gin.Context) {
	cmd := exec.Command(exe, args...)
	var in bytes.Buffer
	cmd.Stdin = &in
	var out bytes.Buffer
	cmd.Stdout = &out

	err := cmd.Run()
	if err != nil {
		println(err.Error())
		return
	}
	ctx.Data(200, "text/plain", out.Bytes())
}

var InExecMutex sync.RWMutex
var InExec bool

func MutexCommandGin(ctx *gin.Context) {

	InExecMutex.RLock()
	if InExec {
		ctx.AbortWithStatusJSON(200, gin.H{"error": "Command is already in execution. Request discarded."})
		InExecMutex.RUnlock()
		return
	}
	InExecMutex.RUnlock()

	var v []string
	err := ctx.ShouldBindJSON(&v)
	if err != nil {
		println(err.Error())
		return
	}

	InExecMutex.Lock()
	InExec = true
	InExecMutex.Unlock()

	Command(ctx.Query("exec"), v, ctx)

	InExecMutex.Lock()
	InExec = false
	InExecMutex.Unlock()
}

func CommandGin(ctx *gin.Context) {
	var v []string
	err := ctx.ShouldBindJSON(&v)
	if err != nil {
		println(err.Error())
		return
	}
	Command(ctx.Query("exec"), v, ctx)
}

type ServerInfo struct {
	GlobalPositioningSystem *GPS               `toml:"GPS"`
	VoiceService            *VoiceCall.Voice   `toml:"VoiceCall"`
	Intercom                *Intercom.Intercom `toml:"Intercom"`
	Alarm                   *Alarm             `toml:"Alarm"`
}

type Alarm struct {
	Volume int `toml:"Volume"`
}

func (receiver *ServerInfo) Refresh() {
	marshal, err := toml.Marshal(receiver)
	if err != nil {
		return
	}
	err = os.WriteFile("./cfg.toml", marshal, 0666)
	if err != nil {
		return
	}
}

func main() {
	var cfg ServerInfo
	var err error
	_, err = toml.DecodeFile("./cfg.toml", &cfg)
	if err != nil {
		panic(err)
		return
	}
	if cfg.VoiceService != nil {
		cfg.VoiceService.SetOnRefresh(cfg.Refresh)
		err = cfg.VoiceService.ConnectRoom()
		if err == nil {
			go func() {
				err := cfg.VoiceService.PushMicrophone()
				if err != nil {
					println(err)
					return
				}
			}()
		} else {
			println(err)
		}
	}

	err = os.Setenv("ALSA_PCM_CARD", "1")
	if err != nil {
		return
	}
	err = os.Setenv("ALSA_PCM_DEVICE", "0")
	if err != nil {
		return
	}
	gin.SetMode(gin.ReleaseMode)
	r := gin.New()
	r.PUT("/MutexCommand", MutexCommandGin)
	r.PUT("/Command", CommandGin)
	r.GET("/Host", Host)
	r.GET("/NetPort", NetPort)
	r.GET("/Memory", Memory)
	r.GET("/Cpu", Cpu)
	r.GET("/Bandwidth", Bandwidth)
	r.GET("/Temperature", Temperature)

	cfg.Intercom.Init()
	r.PUT("/Mailbox", func(ctx *gin.Context) {
		data, err := ctx.GetRawData()
		if err != nil {
			return
		}
		cfg.Intercom.Add(data)
	})
	go cfg.Intercom.Start()

	var Q QuectelAT.Quectel
	err = Q.Open()
	if err == nil {
		r.GET("/MobileSignal", func(context *gin.Context) {
			if data, err := Q.GetCSQ(); err != nil {
				context.JSON(400, gin.H{"error": err.Error()})
			} else {
				context.JSON(200, data)
			}
		})
	}

	if cfg.GlobalPositioningSystem != nil {
		err = cfg.GlobalPositioningSystem.Open()
		if err != nil {
			return
		}
		r.GET("/GPS", cfg.GlobalPositioningSystem.ObtainLatitudeAndLongitude)
	}

	err = r.Run(":4000")
	if err != nil {
		println(err)
		return
	}
}