package can

import (
	"bufio"
	"fmt"
	"os"
	"regexp"
	"strconv"
)

// (2022-07-08 16:54:15.587099)  can0  100   [8]  00 00 00 00 00 00 64 00
// (1670578900.771868) can0 00004021#00000000FCFFFFFF
const EXPR_HR = "\\((.*)\\)\\s+can\\d+\\s+(\\S+)\\s+\\[\\d\\]\\s+([A-F0-9]+)\\s+([A-F0-9]+)\\s+([A-F0-9]+)\\s+([A-F0-9]+)\\s+([A-F0-9]+)\\s+([A-F0-9]+)\\s+([A-F0-9]+)\\s+([A-F0-9]+)"
const EXPR_M = "\\((.*)\\)\\s+can\\d+\\s+(\\S+)#([A-F0-9]{2})([A-F0-9]{2})([A-F0-9]{2})([A-F0-9]{2})([A-F0-9]{2})([A-F0-9]{2})([A-F0-9]{2})([A-F0-9]{2})"
const length = 11

var patternHr = regexp.MustCompile(EXPR_HR)
var patternM = regexp.MustCompile(EXPR_M)

func Readfile(filename *string) <-chan *CanFrame {
	c := make(chan *CanFrame)

	go func() {
		defer close(c)

		file, err := os.Open(*filename)
		if err != nil {
			fmt.Println(err)
			os.Exit(1)
		}
		defer file.Close()

		scanner := bufio.NewScanner(file)
		process(scanner, c)
	}()

	return c
}

func process(scanner *bufio.Scanner, ch chan<- *CanFrame) {
	for scanner.Scan() {
		text := scanner.Text()
		if frame := fromString(&text); frame != nil {
			ch <- frame
		}
	}

	if err := scanner.Err(); err != nil {
		fmt.Println(err)
	}
}

func ReadStdin() <-chan *CanFrame {
	c := make(chan *CanFrame)

	go func() {
		scanner := bufio.NewScanner(os.Stdin)
		process(scanner, c)
	}()
	return c
}

func fromString(text *string) *CanFrame {
	var submatch []string
	if submatch = patternHr.FindStringSubmatch(*text); submatch == nil {
		if submatch = patternM.FindStringSubmatch(*text); submatch == nil {
			return nil
		}
	}

	if len(submatch) == length {
		canid, err := strconv.ParseUint(submatch[2], 16, 0)
		if err != nil {
			return nil
		}

		payload := make([]uint8, 8)
		for idx, octet := range submatch[3:] {
			val, err := strconv.ParseUint(octet, 16, 0)
			if err != nil {
				fmt.Println(err)
				continue
			}

			payload[idx] = uint8(val)
		}

		return &CanFrame{
			Date:    submatch[1],
			CanId:   uint32(canid),
			Payload: payload,
		}
	}

	return nil
}