unix

package main

import (
	"bufio"
	"bytes"
	"context"
	"fmt"
	"io"
	"log"
	"os"
	"strings"

	"codeberg.org/gonix/gio/pipe"
	. "codeberg.org/gonix/gio/unix"
)

// Cat
// aka cat
type Cat struct {
	cat []byte
}

func (c Cat) Run(ctx context.Context, stdio StandardIO) error {
	buf := bytes.NewBuffer(c.cat)
	_, err := io.Copy(stdio.Stdout(), buf)
	return err
}

// CountLines counts a number of read lines
// aka wc -l
type CountLines struct{}

func (c CountLines) Run(ctx context.Context, stdio StandardIO) error {
	counter := 0
	r := bufio.NewScanner(stdio.Stdin())
	for r.Scan() {
		counter++
	}
	if r.Err() != nil {
		return r.Err()
	}
	fmt.Fprintf(stdio.Stdout(), "%d\n", counter)
	return nil
}

// Pipe runs commands via pipe
// err := NewPipe().Run(ctx, stdio, cat, wc)
// is cat | wc -l
type Pipe struct {
	pipe.Line[byte]
}

func NewPipe() Pipe {
	return Pipe{Line: pipe.NewLine[byte]()}
}

func (p Pipe) Pipefail(b bool) Pipe {
	return Pipe{Line: p.Line.Pipefail(b)}
}

func (p Pipe) Run(ctx context.Context, stdio StandardIO, filters ...Filter) error {
	pipeio := pipe.NewStdio[byte](stdio.Stdin(), stdio.Stdout(), stdio.Stderr())
	pipefilters := make([]pipe.Filter[byte], len(filters))
	for idx, f := range filters {
		pipefilters[idx] = pipeFilter{filter: f}
	}

	return p.Line.Run(ctx, pipeio, pipefilters...)
}

type pipeFilter struct {
	filter Filter
}

func (f pipeFilter) Run(ctx context.Context, stdio pipe.StandardIO[byte]) error {
	unixio := NewStdio(stdio.Stdin(), stdio.Stdout(), stdio.Stderr())
	return f.filter.Run(ctx, unixio)
}

func main() {
	ctx := context.Background()
	cat := Cat{
		cat: []byte("three\nsmall\npigs\n"),
	}
	wc := CountLines{}

	var out strings.Builder
	stdio := NewStdio(
		nil,
		&out,
		os.Stderr,
	)

	// an equivalent of cat | wc -l
	err := NewPipe().Run(ctx, stdio, cat, wc)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println(out.String())
}

Output:
3