package card_pusher

import (
	"fmt"
	"github.com/warthog618/go-gpiocdev"
	"go.uber.org/zap"
	"strings"
	"time"
)

type Device struct {
	lines     *LineGroup
	chip      *gpiocdev.Chip      // GPIO 设备
	inLines   *gpiocdev.Lines     // 输入针脚
	pushLine  *gpiocdev.Line      // 发卡针脚
	pullLine  *gpiocdev.Line      // 回收针脚
	resetLine *gpiocdev.Line      // 重置针脚
	status    map[int]*StatusLine // 状态
	cache     map[int]int
}

// statusEventHandler 状态事件处理
func (d *Device) statusEventHandler(evt gpiocdev.LineEvent) {
	offset := evt.Offset
	eType := evt.Type

	if v, ok := d.status[offset]; ok {
		defer func() {
			v.SubEvent(func(i int) {
				labels := d.lines.AllLabel()
				zap.S().Infof("状态: %s-%d", labels[offset], i)
			})
		}()

		if eType == gpiocdev.LineEventFallingEdge {
			if v.Get() == 0 {
				return
			} else {
				v.AfterSet(0)
			}
		} else if eType == gpiocdev.LineEventRisingEdge {
			if v.Get() == 1 {
				return
			} else {
				v.AfterSet(1)
			}
		}
	}
}

// initStatus 读取初始状态
func (d *Device) initStatus() error {
	offsets := d.inLines.Offsets()
	status := make([]int, len(offsets))
	err := d.inLines.Values(status)
	if err != nil {
		return err
	}
	for i := range status {
		d.status[offsets[i]] = DefaultStatusLine(status[i])
	}

	sv := make([]string, len(offsets))
	labels := d.lines.AllLabel()
	for _, g := range d.lines.AllInLines() {
		sv = append(sv, fmt.Sprintf("%s-%s", labels[g], d.status[g]))
	}
	strings.Join(sv, " ")
	zap.S().Infof("初始状态: %s", strings.Join(sv, " "))

	return nil
}

// Close 关闭设备
func (d *Device) Close() error {
	d.resetLine.Close()
	d.pullLine.Close()
	d.pushLine.Close()

	d.inLines.Close()
	d.chip.Close()

	return nil
}

// PushCard 发卡
func (d *Device) PushCard() {
	d.pushLine.SetValue(1)
	defer d.pushLine.SetValue(0)

	time.Sleep(500 * time.Millisecond)
}

// PullCard 回收卡
func (d *Device) PullCard() {
	d.pullLine.SetValue(1)
	defer d.pullLine.SetValue(0)

	time.Sleep(500 * time.Millisecond)
}

// Reset 重置
func (d *Device) Reset() {
	d.resetLine.SetValue(1)
	defer d.resetLine.SetValue(0)

	time.Sleep(500 * time.Millisecond)
}

func (d *Device) GetOutOk() int {
	return d.status[d.lines.OutOK].Get()
}

func (d *Device) GetLower() int {
	return d.status[d.lines.Lower].Get()
}

func (d *Device) GetError() int {
	return d.status[d.lines.Error].Get()
}

func (d *Device) GetEmpty() int {
	return d.status[d.lines.Empty].Get()
}

func New(lines *LineGroup) (*Device, error) {
	if !lines.Ok() {
		return nil, fmt.Errorf("针脚配置错误")
	}

	chip, err := gpiocdev.NewChip(lines.Name, gpiocdev.AsActiveLow)
	if err != nil {
		return nil, fmt.Errorf("打开 GPIO 设备失败: %w", err)
	}

	d := &Device{
		lines:  lines,
		chip:   chip,
		status: make(map[int]*StatusLine),
	}

	// 初始化输入针脚并监听针脚
	inLines, err := chip.RequestLines(
		lines.AllInLines(),              // 请求所有输入引脚
		gpiocdev.AsInput,                // 请求引脚作为输入
		gpiocdev.WithPullUp,             // 使用上拉电阻
		gpiocdev.WithRealtimeEventClock, // 使用实时时钟
		gpiocdev.WithBothEdges,          // 监听上升沿和下降沿
		gpiocdev.WithEventHandler(d.statusEventHandler),
	)
	if err != nil {
		return nil, fmt.Errorf("请求输入引脚失败: %w", err)
	}
	d.inLines = inLines

	// 读取初始状态
	err = d.initStatus()
	if err != nil {
		return nil, fmt.Errorf("读取初始状态失败: %w", err)
	}

	// 初始化发卡引脚
	push, err := chip.RequestLine(lines.Push, gpiocdev.AsOutput())
	if err != nil {
		return nil, fmt.Errorf("请求引脚 %d 作为发卡失败: %w", lines.Push, err)
	}
	d.pushLine = push

	// 初始化回收引脚
	pull, err := chip.RequestLine(lines.Pull, gpiocdev.AsOutput())
	if err != nil {
		return nil, fmt.Errorf("请求引脚 %d 作为回收失败: %w", lines.Pull, err)
	}
	d.pullLine = pull

	// 初始化重置引脚
	reset, err := chip.RequestLine(lines.Reset, gpiocdev.AsOutput())
	if err != nil {
		return nil, fmt.Errorf("请求引脚 %d 作为重置失败: %w", lines.Reset, err)
	}
	d.resetLine = reset

	return d, nil
}
