package s19

import (
	"encoding/hex"
	"fmt"
	"os"
)

// writeSRecord creates a formatted S-record line
func writeSRecord(record SRecord) (string, error) {
	var addressLength int
	switch record.Type {
	case "S1": // 2-byte address
		addressLength = 2
	case "S2": // 3-byte address
		addressLength = 3
	case "S3": // 4-byte address
		addressLength = 4
	case "S9": // Termination record with a 2-byte start address
		addressLength = 2
	default:
		return "", fmt.Errorf("unsupported record type: %s", record.Type)
	}

	// Calculate the byte count: address bytes + data bytes + checksum byte
	byteCount := 1 + addressLength + len(record.Data)

	// Create the record string
	addressFormat := fmt.Sprintf("%%0%dX", addressLength*2)
	address := fmt.Sprintf(addressFormat, record.Address)

	// Convert data to hexadecimal string
	data := hex.EncodeToString(record.Data)

	// Combine all components
	body := fmt.Sprintf("%02X%s%s", byteCount, address, data)

	// Compute checksum
	checksum := computeChecksum(body)

	// Construct the final S-record
	return fmt.Sprintf("S%s%s%02X", record.Type[1:], body, checksum), nil
}

// computeChecksum calculates the checksum for an S-record
func computeChecksum(body string) byte {
	sum := byte(0)
	for i := 0; i < len(body); i += 2 {
		value, _ := hex.DecodeString(body[i : i+2])
		sum += value[0]
	}
	return ^sum
}

// writeS19File creates an S19 file with the provided records
func writeS19File(filename string, records []SRecord) error {
	file, err := os.Create(filename)
	if err != nil {
		return err
	}
	defer file.Close()

	for _, record := range records {
		line, err := writeSRecord(record)
		if err != nil {
			return err
		}
		_, err = file.WriteString(line + "\n")
		if err != nil {
			return err
		}
	}
	return nil
}

func main() {
	// Example data to write
	data := []byte("Hello, S19 world!")

	// Create a list of records
	records := []SRecord{
		{
			Type:    "S1",
			Address: 0x1000,
			Data:    data[:8], // First chunk
		},
		{
			Type:    "S1",
			Address: 0x1008,
			Data:    data[8:], // Second chunk
		},
		{
			Type:    "S9",
			Address: 0x1000, // Start address for the program
			Data:    nil,
		},
	}

	// Write the records to a file
	err := writeS19File("output.s19", records)
	if err != nil {
		fmt.Printf("Error writing S19 file: %v\n", err)
		return
	}

	fmt.Println("S19 file written successfully.")
}