package slackware_com

import (
	"errors"
	"fmt"
	"path"
	"strconv"
	"strings"
	"unicode"
)

func VerifyPackageFile(filePath string, ascFilePath string) (bool, error) {
	return true, nil
}

type PackageName struct {
	Application string
	Version     string
	Arch        string
	Build       int
	Tag         string
}

func parseBuildTag(str string) (int, string, error) {
	runes := []rune(str)

	var v []rune
	for _, r := range runes {
		if !unicode.IsDigit(r) {
			break
		}
		v = append(v, r)
	}
	build, err := strconv.Atoi(string(v))
	if err != nil {
		return 0, "", fmt.Errorf("build number: %w", err)
	}

	return build, str[len(v):], err
}

func NewPackageName(name string) (PackageName, error) {
	strs := strings.Split(name, "-")
	if len(strs) < 4 {
		return PackageName{}, fmt.Errorf("badly formatted package name '%s'", name)
	}

	build, tag, err := parseBuildTag(strs[len(strs)-1])
	if err != nil {
		return PackageName{}, err
	}

	return PackageName{
		Application: strings.Join(strs[:len(strs)-3], "-"),
		Version:     strs[len(strs)-3],
		Arch:        strs[len(strs)-2],
		Build:       build,
		Tag:         tag,
	}, nil
}

func MustPackageName(name string) PackageName {
	pkg, err := NewPackageName(name)
	if err != nil {
		panic(err)
	}
	return pkg
}

func NewPackageNameFromPath(filePath string) (PackageName, error) {
	fileName := path.Base(filePath)
	str, ok := strings.CutSuffix(fileName, path.Ext(fileName))
	if !ok {
		return PackageName{}, errors.New("file extension missing")
	}
	return NewPackageName(str)
}

func IsPackage(filePath string) bool {
	ext := path.Ext(filePath)
	switch ext {
	case ".tbz", ".tgz", ".tlz", ".txz":
		return true
	default:
		return false
	}
}

func (p *PackageName) String() string {
	return fmt.Sprintf("%s-%s-%s-%d%s", p.Application, p.Version, p.Arch, p.Build, p.Tag)
}

func (p *PackageName) AppplicationVersion() string {
	return fmt.Sprintf("%s-%s", p.Application, p.Version)
}

// PackageNamePattern is the shorthand string used to specify a package.
type PackageNamePattern string

func MustPackageNamePattern(name string) PackageNamePattern {
	return PackageNamePattern(name)
}

func (p *PackageNamePattern) IsMatch(pkg PackageName) bool {
	return p.String() == pkg.Application ||
		p.String() == fmt.Sprintf("%s-%s", pkg.Application, pkg.Version)
}

func (p *PackageNamePattern) String() string {
	return string(*p)
}