main_test.go

// Copyright 2026 Arsham Shirvani <arshamshirvani@gmail.com>. All rights reserved.
// Use of this source code is governed by the Apache 2.0 license.
// License can be found in the LICENSE file.

package main

import (
	"bytes"
	"os"
	"path/filepath"
	"slices"
	"strconv"
	"strings"
	"testing"
)

const testFontName = "Poison.flf"

func TestParseArgsCombinesShortBooleanFlags(t *testing.T) {
	opts, input, err := parseArgs([]string{"-ls", "Sample", "Text"})
	if err != nil {
		t.Fatalf("parse args: %v", err)
	}
	if !opts.listFonts {
		t.Fatal("list flag was not set")
	}
	if !opts.showSample {
		t.Fatal("sample flag was not set")
	}
	if !slices.Equal(input, []string{"Sample", "Text"}) {
		t.Fatalf("input = %q, want Sample Text", input)
	}
}

func TestParseArgsReadsLongFontValue(t *testing.T) {
	opts, input, err := parseArgs([]string{"--font", testFontName, "hello"})
	if err != nil {
		t.Fatalf("parse args: %v", err)
	}
	if opts.fontName != testFontName {
		t.Fatalf("font name = %q, want %s", opts.fontName, testFontName)
	}
	if !slices.Equal(input, []string{"hello"}) {
		t.Fatalf("input = %q, want hello", input)
	}
}

func TestParseArgsStopsAtSeparator(t *testing.T) {
	_, input, err := parseArgs([]string{"--", "--not-a-flag"})
	if err != nil {
		t.Fatalf("parse args: %v", err)
	}
	if !slices.Equal(input, []string{"--not-a-flag"}) {
		t.Fatalf("input = %q, want --not-a-flag", input)
	}
}

func TestParseArgsReportsUnknownFlag(t *testing.T) {
	_, _, err := parseArgs([]string{"--bogus"})
	if err == nil {
		t.Fatal("expected an error")
	}
	if !strings.Contains(err.Error(), "unknown flag --bogus") {
		t.Fatalf("error = %q, want unknown flag", err)
	}
}

func TestRunHelpWritesUsefulUsage(t *testing.T) {
	var stdout bytes.Buffer
	var stderr bytes.Buffer

	code := run([]string{"--help"}, &stdout, &stderr)
	if code != 0 {
		t.Fatalf("exit code = %d, want 0", code)
	}
	if stderr.Len() != 0 {
		t.Fatalf("stderr = %q, want empty", stderr.String())
	}
	output := stdout.String()
	for _, want := range []string{"Usage:", "Examples:", "-ls Sample Text", "--font name"} {
		if !strings.Contains(output, want) {
			t.Fatalf("help output does not contain %q", want)
		}
	}
}

func TestListAvailableFontsHidesLegacyAliases(t *testing.T) {
	var stdout bytes.Buffer

	listAvailableFonts(&stdout, nil, false)
	output := stdout.String()
	for _, want := range []string{"AMC 3 Line.flf\n", "Big Chief.flf\n", "s-relief.flf\n"} {
		if !strings.Contains(output, want) {
			t.Fatalf("font list does not contain %q", want)
		}
	}
	for _, unwanted := range []string{"dotmatrix.flf", "drpepper.flf", "usaflag.flf"} {
		if strings.Contains(output, unwanted) {
			t.Fatalf("font list contains legacy alias %q", unwanted)
		}
	}
}

func TestDecorateAcceptsIdenticalFontAliases(t *testing.T) {
	var stdout bytes.Buffer

	err := decorate(&stdout, "hello", "dotmatrix.flf", true)
	if err != nil {
		t.Fatalf("decorate with identical font alias: %v", err)
	}
	if !strings.Contains(stdout.String(), "Font: Dot Matrix.flf\n") {
		t.Fatalf("visual output did not use canonical font name: %q", stdout.String())
	}
}

func TestDecoratePreservesDistinctSimilarFontNames(t *testing.T) {
	var stdout bytes.Buffer

	err := decorate(&stdout, "hello", "3d.flf", true)
	if err != nil {
		t.Fatalf("decorate with distinct similar font name: %v", err)
	}
	if !strings.Contains(stdout.String(), "Font: 3d.flf\n") {
		t.Fatalf("visual output did not preserve font name: %q", stdout.String())
	}
}

func TestDecorateAcceptsCanonicalFontNames(t *testing.T) {
	var stdout bytes.Buffer

	err := decorate(&stdout, "hello", "AMC 3 Line.flf", true)
	if err != nil {
		t.Fatalf("decorate with canonical font name: %v", err)
	}
	if !strings.Contains(stdout.String(), "Font: AMC 3 Line.flf\n") {
		t.Fatalf("visual output did not use canonical font name: %q", stdout.String())
	}
}

func TestListedFontsHaveVisibleHyphenGlyph(t *testing.T) {
	for _, fontName := range fontNames {
		fontName := fontName
		t.Run(fontName, func(t *testing.T) {
			data, err := os.ReadFile(filepath.Join("figurine", "fonts", fontName))
			if err != nil {
				t.Fatalf("read font: %v", err)
			}
			if blankHyphenGlyph(data) {
				t.Fatal("hyphen glyph is blank")
			}
		})
	}
}

func blankHyphenGlyph(data []byte) bool {
	lines := bytes.Split(data, []byte("\n"))
	fields := strings.Fields(string(bytes.TrimRight(lines[0], "\r")))
	height, _ := strconv.Atoi(fields[1])
	commentLines, _ := strconv.Atoi(fields[5])
	start := 1 + commentLines + (int('-')-32)*height
	hardblank := fields[0][len(fields[0])-1:]

	for _, line := range lines[start : start+height] {
		line = bytes.TrimRight(line, "\r")
		line = bytes.TrimRight(line, "@")
		line = bytes.ReplaceAll(line, []byte(hardblank), []byte(" "))
		if strings.TrimSpace(string(line)) != "" {
			return false
		}
	}
	return true
}