package main

import (
	phomemofilter "brainbaking.com/phomemoprinter/filter"
	"log"
	"os"
	"os/exec"
	"strconv"
	"strings"
	"time"
	"tinygo.org/x/bluetooth"
)

var adapter = bluetooth.DefaultAdapter
var phomemoFolder = "/Downloads/phomemo"

func main() {
	home, _ := os.UserHomeDir()
	inDir := home + phomemoFolder

	files, err := os.ReadDir(inDir)
	must(phomemoFolder + " does not exist", err)
	if len(files) == 0 {
		log.Printf("No files to print found in %s, nothing to do. Quitting.\n", inDir)
		os.Exit(0)
	}

	must("Enable Bluetooth stack", adapter.Enable())

	log.Println("Scanning for Bluetooth devices...")
	ch := make(chan bluetooth.ScanResult, 1)
	timeout := make(chan bool, 1)
	go func() {
		time.Sleep(10 * time.Second)
		timeout <- true
	}()

	go func() {
		err = adapter.Scan(func(adapter *bluetooth.Adapter, device bluetooth.ScanResult) {
			if device.LocalName() == "Mr.in_M02" {
				ch <- device
				adapter.StopScan()
			}
		})
		must("start scan", err)
	}()

	select {
	case device := <- ch:
		log.Println("Found device: ", device.Address.String(), device.RSSI, device.LocalName())		
		tryToPrint(device, inDir, files)
	case <- timeout:
		log.Fatal("Timeout trying to locate Phomemo M02, is it on? Quitting.")
	}

}

func tryToPrint(phomemoAddress bluetooth.ScanResult, dir string, files []os.DirEntry) {
	var phomemo *bluetooth.Device
	phomemo, err := adapter.Connect(phomemoAddress.Address, bluetooth.ConnectionParams{})
	must("failed to connect to adapter", err)
	log.Println("connected to ", phomemoAddress.Address.String())
	defer func() {
		if err := phomemo.Disconnect(); err != nil {
			log.Println(err)
		} else {
			log.Println("disconnected")
		}
	}()

	srvcs, err := phomemo.DiscoverServices(nil)
	must("failed to discover service", err)
	log.Println("Discovering all services on device...")

	srvc := srvcs[0] // there's only one (0000ff00-...) anyway
	log.Println("- service", srvc.UUID().String())

	chars, err := srvc.DiscoverCharacteristics(nil)
	must("failed to discover characteristics of service", err)

	pyfilterloc := dir + "/" + "phomemo-filter.py"
	dumpFilter(pyfilterloc)
	defer func() {
		os.RemoveAll(pyfilterloc)
	}()

	// 3 characteristics to discover 0000ff01, 0000ff02, and 0000ff03
	for _, file := range files {
		filePath := dir + "/" + file.Name()
		if isPossibleToPrint(filePath) {
			writeData(pyfilterloc, filePath, chars[1]) // 0000ff02-...
			readResult(chars[0])          // 0000ff01-...
			os.RemoveAll(filePath)
		}
	}

	log.Println("-- DONE")
}

func isPossibleToPrint(filename string) bool {
	return strings.HasSuffix(filename, ".jpg") ||
		strings.HasSuffix(filename, ".JPG") ||
		strings.HasSuffix(filename, ".png") ||
		strings.HasSuffix(filename, ".PNG")
}

func dumpFilter(filename string) {
	err := os.WriteFile(filename, phomemofilter.Pyfilter, 0666)
	must("unable to dump python filter for use", err)
}

func writeData(pyfilterloc string, path string, char bluetooth.DeviceCharacteristic) {
	// first, it needs to be prepared for the printer
	pathpho := path + ".pho"
	argstr := []string{"-c", "/usr/local/bin/python " + pyfilterloc + " " + path + " > " + pathpho}
	log.Println("args", argstr)
	_, err := exec.Command("/bin/zsh", argstr...).Output()
	must("something went wrong while filtering phomemo data py", err)

	data, _ := os.ReadFile(pathpho)

	log.Printf("-- writing file %s to characteristic %s\n", path, char.UUID().String())
	_, err = char.WriteWithoutResponse(data)
	if err != nil {
		log.Println("    ", err.Error())
	}
	time.Sleep(1 * time.Second)
	os.RemoveAll(pathpho)
}

func readResult(char bluetooth.DeviceCharacteristic) {
	log.Println("-- reading from to characteristic", char.UUID().String())

	buf := make([]byte, 28)
	n, err := char.Read(buf)
	if err != nil {
		log.Println("    ", err.Error())
	} else {
		log.Println("    data bytes", strconv.Itoa(n))
		log.Println("    value =", buf[:n])
	}
	time.Sleep(1 * time.Second)
}

func must(action string, err error) {
	if err != nil {
		panic("failed to " + action + ": " + err.Error())
	}
}