package testrunner

import (
	"fmt"
	"slices"
	"time"

	"alox.tool/api"
	"alox.tool/uart"
)

func (tr *TestRunner) RunEchoTest() error {
	frame, err := tr.Expect(api.CmdEcho, []byte{0x01}, api.CmdEcho, 1*time.Second)
	if err != nil {
		return err
	}

	if frame.Data[0] != 0x01 {
		return fmt.Errorf("Got % X expected % X", frame.Data[0], 0x01)
	}

	return nil
}

func (tr *TestRunner) RunVersionTest() error {
	frame, err := tr.Expect(api.CmdVersion, nil, api.CmdVersion, 1*time.Second)
	if err != nil {
		return err
	}

	// TODO: Check Version and Buildhash?
	_, err = uart.ParseFrameVersion(*frame)
	if err != nil {
		return err
	}

	v, err := uart.ParseFrameVersion(*frame)
	if v.Version != 1 {
		return fmt.Errorf("Got %d expected %d", v.Version, 1)
	}

	return nil
}

func (tr *TestRunner) RunClientInfoTest() error {
	_, err := tr.Expect(api.CmdClientInfo, nil, api.CmdClientInfo, 1*time.Second)
	if err != nil {
		return err
	}

	// TODO: Real Check
	return nil
}

func (tr *TestRunner) RunClientInputTest() error {
	_, err := tr.Expect(api.CmdClientInput, nil, api.CmdClientInput, 1*time.Second)
	if err != nil {
		return err
	}

	// TODO: Real Check
	return nil
}

func (tr *TestRunner) RebuildNetwork() error {

	// Hardcoded for now
	Clients := map[string]string{
		"C1": "/dev/ttyACM1",
		"C2": "/dev/ttyACM2",
		"C3": "/dev/ttyACM3",
		"C4": "/dev/ttyACM4",
	}

	// Hardcoded for now
	macAddresses := [][6]byte{
		{0x50, 0x78, 0x7D, 0x18, 0x85, 0xA0},
		{0x50, 0x78, 0x7D, 0x18, 0x7D, 0x74},
		{0x50, 0x78, 0x7D, 0x18, 0x1D, 0x14},
		{0x50, 0x78, 0x7D, 0x18, 0x00, 0x10},
	}

	// Hardcoded for now
	err := RestartESPOnPort("/dev/ttyACM0")
	if err != nil {
		return fmt.Errorf("Could not Restart Master!")
	}
	time.Sleep(500 * time.Millisecond)

	for c, p := range Clients {
		fmt.Printf("Restarting Client %v", c)
		err = RestartESPOnPort(p)
		if err != nil {
			fmt.Printf("Could not Restart Client %v on Port %v", c, p)
			return err
		}
		time.Sleep(500 * time.Millisecond)
	}

	success := false
	var frame *api.Frame
	var clientInfos []api.PayloadClientInfo
	var lastError string
	for i := 0; i <= 5; i++ {
		time.Sleep(1000 * time.Millisecond) // inital sleep for first network setup

		var err error // for local error scope
		frame, err = tr.Expect(api.CmdClientInfo, nil, api.CmdClientInfo, 1*time.Second)
		if err != nil {
			lastError = "No Uart Message"
			continue
		}

		clientInfos, err = uart.ParseFrameClientInfo(*frame)
		if err != nil {
			lastError = fmt.Sprintf("Could not parse Message: %v", err)
			continue
		}

		if len(clientInfos) != len(macAddresses) {
			lastError = fmt.Sprintf("Want %v Clients, got %v Clients", len(macAddresses), len(clientInfos))
			continue
		}
		success = true
		break
	}

	if !success {
		return fmt.Errorf("%v", lastError)
	}

	for _, client := range clientInfos {
		if !slices.Contains(macAddresses, client.MACAddr) {
			return fmt.Errorf("Client %v not found in expected list %v", client.MACAddr, macAddresses)
		}
	}

	return nil
}