//go:build windows

/*
 * ============================================================================
 * Projekt.....: rs2322tcp
 * Datei.......: cmd/com0com-test/main.go
 * Copyright (C) 2026 Dieter Lang
 *
 * SPDX-License-Identifier: GPL-3.0-or-later
 *
 * Beschreibung:
 * Direkter Test eines com0com-Portpaares.
 *
 * Der Test öffnet COM100 und COM10 gleichzeitig und überprüft die
 * Datenübertragung in beide Richtungen:
 *
 *     COM100 -> COM10
 *     COM10  -> COM100
 *
 * Dadurch kann die Funktion von com0com und go.bug.st/serial unabhängig
 * vom rs2322tcp-Client, TCP-Server und PTY-Testaufbau geprüft werden.
 * ============================================================================
 */

package main

import (
	"fmt"
	"log"
	"time"

	"go.bug.st/serial"
)

func main() {
	fmt.Println("rs2322tcp com0com Direkt-Test")
	fmt.Println()

	mode := &serial.Mode{
		BaudRate: 600,
		DataBits: 8,
		Parity:   serial.NoParity,
		StopBits: serial.OneStopBit,
	}

	com10, err := serial.Open("COM10", mode)
	if err != nil {
		log.Fatalf("COM10 öffnen: %v", err)
	}
	defer com10.Close()

	fmt.Println("COM10 geöffnet.")

	com100, err := serial.Open("COM100", mode)
	if err != nil {
		log.Fatalf("COM100 öffnen: %v", err)
	}
	defer com100.Close()

	fmt.Println("COM100 geöffnet.")
	fmt.Println()

	// ------------------------------------------------------------------------
	// Test 1: COM100 -> COM10
	// ------------------------------------------------------------------------

	request := []byte{
		0x57,
		0x00,
		0x00,
		0x00,
		0x00,
		0x00,
		0x00,
		0x00,
		0x00,
		0x00,
		0x00,
		0x1F,
		0x20,
	}

	fmt.Printf(
		"COM100 TX: %d Bytes\n",
		len(request),
	)
	printHex(request)

	n, err := com100.Write(request)
	if err != nil {
		log.Fatalf("COM100 schreiben: %v", err)
	}

	if n != len(request) {
		log.Fatalf(
			"COM100 schreiben: %d von %d Bytes geschrieben",
			n,
			len(request),
		)
	}

	fmt.Println("COM100 schreiben erfolgreich.")

	received := make([]byte, len(request))

	if err := com10.SetReadTimeout(2 * time.Second); err != nil {
		log.Fatalf("COM10 ReadTimeout setzen: %v", err)
	}

	n, err = com10.Read(received)
	if err != nil {
		log.Fatalf("COM10 lesen: %v", err)
	}

	fmt.Printf(
		"COM10 RX: %d Bytes\n",
		n,
	)
	printHex(received[:n])

	if n != len(request) {
		log.Fatalf(
			"COM10: %d Bytes empfangen, erwartet %d",
			n,
			len(request),
		)
	}

	if !equalBytes(request, received[:n]) {
		log.Fatal("COM10: empfangene Daten stimmen nicht mit den gesendeten Daten überein")
	}

	fmt.Println("Test COM100 -> COM10 erfolgreich.")
	fmt.Println()

	// ------------------------------------------------------------------------
	// Test 2: COM10 -> COM100
	// ------------------------------------------------------------------------

	response := []byte{
		0x57,
		0x07,
		0x01,
		0x06,
		0x00,
		0x01,
		0x03,
		0x06,
		0x02,
		0x00,
		0x01,
		0x20,
	}

	fmt.Printf(
		"COM10 TX: %d Bytes\n",
		len(response),
	)
	printHex(response)

	n, err = com10.Write(response)
	if err != nil {
		log.Fatalf("COM10 schreiben: %v", err)
	}

	if n != len(response) {
		log.Fatalf(
			"COM10 schreiben: %d von %d Bytes geschrieben",
			n,
			len(response),
		)
	}

	fmt.Println("COM10 schreiben erfolgreich.")

	received = make([]byte, len(response))

	if err := com100.SetReadTimeout(2 * time.Second); err != nil {
		log.Fatalf("COM100 ReadTimeout setzen: %v", err)
	}

	n, err = com100.Read(received)
	if err != nil {
		log.Fatalf("COM100 lesen: %v", err)
	}

	fmt.Printf(
		"COM100 RX: %d Bytes\n",
		n,
	)
	printHex(received[:n])

	if n != len(response) {
		log.Fatalf(
			"COM100: %d Bytes empfangen, erwartet %d",
			n,
			len(response),
		)
	}

	if !equalBytes(response, received[:n]) {
		log.Fatal("COM100: empfangene Daten stimmen nicht mit den gesendeten Daten überein")
	}

	fmt.Println("Test COM10 -> COM100 erfolgreich.")
	fmt.Println()

	fmt.Println("==========================================")
	fmt.Println("Alle com0com-Direkt-Tests erfolgreich.")
	fmt.Println("==========================================")
}

// printHex gibt einen Byte-Block hexadezimal aus.
func printHex(data []byte) {
	for i, b := range data {
		if i > 0 {
			fmt.Print(" ")
		}

		fmt.Printf("%02X", b)
	}

	fmt.Println()
}

// equalBytes compares two byte slices.
func equalBytes(a, b []byte) bool {
	if len(a) != len(b) {
		return false
	}

	for i := range a {
		if a[i] != b[i] {
			return false
		}
	}

	return true
}