package imageext

import (
	"testing"

	"git.blackforestbytes.com/BlackForestBytes/goext/tst"
)

func TestImageFit_Valid(t *testing.T) {
	tst.AssertTrue(t, ImageFitStretch.Valid())
	tst.AssertTrue(t, ImageFitCover.Valid())
	tst.AssertTrue(t, ImageFitContainCenter.Valid())
	tst.AssertTrue(t, ImageFitContainTopLeft.Valid())
	tst.AssertTrue(t, ImageFitContainTopRight.Valid())
	tst.AssertTrue(t, ImageFitContainBottomLeft.Valid())
	tst.AssertTrue(t, ImageFitContainBottomRight.Valid())

	tst.AssertFalse(t, ImageFit("UNKNOWN").Valid())
	tst.AssertFalse(t, ImageFit("").Valid())
}

func TestImageFit_String(t *testing.T) {
	tst.AssertEqual(t, ImageFitStretch.String(), "STRETCH")
	tst.AssertEqual(t, ImageFitCover.String(), "COVER")
	tst.AssertEqual(t, ImageFitContainCenter.String(), "CONTAIN_CENTER")
}

func TestImageFit_VarName(t *testing.T) {
	tst.AssertEqual(t, ImageFitStretch.VarName(), "ImageFitStretch")
	tst.AssertEqual(t, ImageFitContainBottomRight.VarName(), "ImageFitContainBottomRight")
	tst.AssertEqual(t, ImageFit("UNKNOWN").VarName(), "")
}

func TestImageFit_TypeName(t *testing.T) {
	tst.AssertEqual(t, ImageFitStretch.TypeName(), "ImageFit")
}

func TestImageFit_Values(t *testing.T) {
	values := ImageFitValues()
	tst.AssertEqual(t, len(values), 7)
	tst.AssertEqual(t, values[0], ImageFitStretch)
}

func TestImageFit_ValuesAny(t *testing.T) {
	tst.AssertEqual(t, len(ImageFitStretch.ValuesAny()), 7)
}

func TestImageFit_ValuesMeta(t *testing.T) {
	meta := ImageFitValuesMeta()
	tst.AssertEqual(t, len(meta), 7)
	tst.AssertEqual(t, meta[0].VarName, "ImageFitStretch")
}

func TestParseImageFit(t *testing.T) {
	v, ok := ParseImageFit("COVER")
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, v, ImageFitCover)

	v, ok = ParseImageFit("CONTAIN_TOPLEFT")
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, v, ImageFitContainTopLeft)

	_, ok = ParseImageFit("BOGUS")
	tst.AssertFalse(t, ok)
}

func TestImageCompresson_Valid(t *testing.T) {
	tst.AssertTrue(t, CompressionPNGNone.Valid())
	tst.AssertTrue(t, CompressionPNGSpeed.Valid())
	tst.AssertTrue(t, CompressionPNGBest.Valid())
	tst.AssertTrue(t, CompressionJPEG100.Valid())
	tst.AssertTrue(t, CompressionJPEG1.Valid())

	tst.AssertFalse(t, ImageCompresson("UNKNOWN").Valid())
	tst.AssertFalse(t, ImageCompresson("").Valid())
}

func TestImageCompresson_String(t *testing.T) {
	tst.AssertEqual(t, CompressionPNGNone.String(), "PNG_NONE")
	tst.AssertEqual(t, CompressionJPEG90.String(), "JPEG_090")
}

func TestImageCompresson_VarName(t *testing.T) {
	tst.AssertEqual(t, CompressionJPEG50.VarName(), "CompressionJPEG50")
	tst.AssertEqual(t, ImageCompresson("UNKNOWN").VarName(), "")
}

func TestImageCompresson_TypeName(t *testing.T) {
	tst.AssertEqual(t, CompressionJPEG50.TypeName(), "ImageCompresson")
}

func TestImageCompresson_Values(t *testing.T) {
	values := ImageCompressonValues()
	tst.AssertEqual(t, len(values), 12)
}

func TestImageCompresson_ValuesAny(t *testing.T) {
	tst.AssertEqual(t, len(CompressionPNGBest.ValuesAny()), 12)
}

func TestImageCompresson_ValuesMeta(t *testing.T) {
	meta := ImageCompressonValuesMeta()
	tst.AssertEqual(t, len(meta), 12)
}

func TestParseImageCompresson(t *testing.T) {
	v, ok := ParseImageCompresson("PNG_BEST")
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, v, CompressionPNGBest)

	v, ok = ParseImageCompresson("JPEG_080")
	tst.AssertTrue(t, ok)
	tst.AssertEqual(t, v, CompressionJPEG80)

	_, ok = ParseImageCompresson("BOGUS")
	tst.AssertFalse(t, ok)
}

func TestAllPackageEnums(t *testing.T) {
	enums := AllPackageEnums()
	tst.AssertEqual(t, len(enums), 2)
}