package main

import (
	"context"
	"flag"
	"fmt"
	"log"
	"os"
	"time"

	"alox.tool/api"
	"alox.tool/eventbus"
	"alox.tool/frontend"
	"alox.tool/state"
	"alox.tool/testrunner"
	"alox.tool/uart"
)

var (
	Tests    bool
	Baudrate uint
)

func main() {
	flag.BoolVar(&Tests, "t", false, "Tests")
	flag.UintVar(&Baudrate, "b", 921600, "Baudrate") // 115200

	flag.Parse()

	log.Printf("Starting with Params %v", Baudrate)

	config := Config{
		Port:     8000,
		Host:     "0.0.0.0",
		UartPort: "/dev/ttyUSB0",
		Baudrate: int(Baudrate),
	}
	if Tests {
		StartTests(config)
		return
	}
	StartApp(config)
}

func StartTests(config Config) {
	bus := eventbus.New()
	com, err := uart.NewCom(bus)
	if err != nil {
		log.Printf("Could not Create COM %v", err)
	}
	err = com.Connect(config.UartPort, config.Baudrate)
	if err != nil {
		log.Printf("Could not Connect with Uart Device %v", err)
	}
	defer com.Close()

	tr := testrunner.New(bus, com)

	testTest := make(map[string]func() error)
	testTest["Echo Test"] = tr.RunEchoTest
	testTest["Version Test"] = tr.RunVersionTest
	testTest["Info Test"] = tr.RunClientInfoTest
	testTest["Input Test"] = tr.RunClientInputTest
	testTest["Rebuild Network"] = tr.RebuildNetwork

	tr.RunTestSet(testTest)
}

func StartApp(config Config) {
	bus := eventbus.New()
	com, err := uart.NewCom(bus)

	ctx, cancle := context.WithCancel(context.Background())
	defer cancle()

	go com.EventbusHandler(ctx)

	if err != nil {
		log.Printf("Could not Create Com with Uart Device %v", err)
		return
	}
	err = com.Connect(config.UartPort, config.Baudrate)
	if err != nil {
		log.Printf("Could not Connect with Uart Device %v", err)
	}
	defer com.Close()

	update, err := os.ReadFile("../espAlox.bin")
	if err != nil {
		log.Printf("Could not read Update file %v", err)
		return
	}
	updateSlices := SliceUpdate(update, 200)

	oManager := NewOTAManager(bus, com, updateSlices)

	espHandle := state.New()
	espHandle.Start(ctx, bus)
	oManager.StartUpdateHandler(ctx)

	time.Sleep(time.Millisecond * 5)

	//tr := testrunner.New(bus, com)
	//tr.RunVersionTest()

	time.Sleep(time.Millisecond * 5)

	//com.Send(api.CmdEcho, make([]byte, 0))
	//com.Send(api.CmdVersion, make([]byte, 0))
	com.Send(api.CmdClientInfo, make([]byte, 0))
	//com.Send(api.CmdClientInput, make([]byte, 0))

	//com.Send(api.CmdOtaStart, make([]byte, 0))
	//com.Send(api.CmdOtaStartEspNow, make([]byte, 0))

	url := fmt.Sprintf("%s:%d", config.Host, config.Port)
	fserver := frontend.New(bus)
	fserver.Start(url)
}

func SliceUpdate(update []byte, maxlen int) [][]byte {
	updateSlices := [][]byte{}
	for i := 0; i < len(update); i += 200 {
		end := min(i+200, len(update))
		updateSlices = append(updateSlices, update[i:end])
	}
	return updateSlices
}