package mailx_test

import (
    "testing"

    "pkg.jfrech.com/brief/mailx"
)

func TestFieldDecode(t *testing.T) {
    field, err := (mailx.RawField("waKKa-wuk: yay\r\n\tyu \r\n yu\r\n")).Decode()
    if err != nil {
        t.Fatal(err)
    }

    if field.Name != "waKKa-wuk" {
        t.Errorf("odd name: %q", field.Name)
    }
    if field.CanonicalName() != "Wakka-Wuk" {
        t.Errorf("odd canonical name: %q", field.CanonicalName())
    }
    if field.Body != "yay\tyu  yu" {
        t.Errorf("odd body: %q", field.Body)
    }
}

type CaseFieldCompare struct {
    Field, Gield mailx.Field

    Ordering int
}

func CasesFieldCompare() []CaseFieldCompare {
    nobody := func(s string) mailx.Field { return mailx.Field{s, ""} }
    return []CaseFieldCompare{
        CaseFieldCompare{nobody(""), nobody(""), 0},
        CaseFieldCompare{nobody(""), nobody("-"), 0},
        CaseFieldCompare{nobody("-"), nobody("-"), 0},
        CaseFieldCompare{nobody("-"), nobody(""), 0},
        CaseFieldCompare{nobody("--"), nobody(""), +1},
        CaseFieldCompare{nobody("-"), nobody("--"), -1},
        CaseFieldCompare{nobody("wakka"), nobody("Wuk"), -1},
        CaseFieldCompare{nobody("Wakka"), nobody("wuK"), -1},
        CaseFieldCompare{nobody("abCDe"), nobody("aBcDE"), 0},
        CaseFieldCompare{nobody("ü"), nobody("--"), 0},
        CaseFieldCompare{nobody("\x80"), nobody("-"), 0},
        CaseFieldCompare{nobody("\x80"), nobody(""), 0},
    }
}

func TestFieldCompare(t *testing.T) {
    for j, tc := range CasesFieldCompare() {
        if ordering := tc.Field.Compare(tc.Gield); ordering != tc.Ordering {
            t.Errorf(
                "CasesFieldCompare()[%d]: (Field{%q, %q}).Compare(Field{%q, %q}) == %+d != %+d",
                j,
                tc.Field.Name, tc.Field.Body,
                tc.Gield.Name, tc.Gield.Body,
                ordering, tc.Ordering,
            )
        }
    }
}

func TestFieldEqual(t *testing.T) {
    for j, tc := range CasesFieldCompare() {
        if equal := tc.Field.Equal(tc.Gield); equal != (tc.Ordering == 0) {
            t.Errorf(
                "CasesFieldCompare()[%d]: (Field{%q, %q}).Equal(Field{%q, %q}) == %t != %t",
                j,
                tc.Field.Name, tc.Field.Body,
                tc.Gield.Name, tc.Gield.Body,
                equal, tc.Ordering == 0,
            )
        }
    }
}

func TestFieldIs(t *testing.T) {
    for j, tc := range CasesFieldCompare() {
        if tc.Field.Body != tc.Gield.Body {
            continue
        }
        if is := tc.Field.Is(tc.Gield.Name); is != (tc.Ordering == 0) {
            t.Errorf(
                "CasesFieldCompare()[%d]: (Field{%q, %q}).Is(%q) == %t != %t",
                j,
                tc.Field.Name, tc.Field.Body,
                tc.Gield.Name,
                is, tc.Ordering == 0,
            )
        }
    }
}

//

type CaseFieldCanonicalName struct {
    Field mailx.Field

    CanonicalName string
}

func CasesFieldCanonicalName() []CaseFieldCanonicalName {
    return []CaseFieldCanonicalName{
        CaseFieldCanonicalName{mailx.Field{"", ""}, "-"},
        CaseFieldCanonicalName{mailx.Field{"-", ""}, "-"},
        CaseFieldCanonicalName{mailx.Field{"::_:", "..!"}, "--_-"},
        CaseFieldCanonicalName{mailx.Field{"Display-Name", "würGl"}, "Display-Name"},
        CaseFieldCanonicalName{mailx.Field{"a", "a"}, "A"},
        CaseFieldCanonicalName{mailx.Field{"aÄa", ""}, "A--A"},
        CaseFieldCanonicalName{mailx.Field{"aÄa-bbüB", ""}, "A--A-Bb--B"},
        CaseFieldCanonicalName{mailx.Field{"disPLay-NAme", "WÜRgL"}, "Display-Name"},
        CaseFieldCanonicalName{mailx.Field{"ä", ""}, "--"},
        CaseFieldCanonicalName{mailx.Field{"ä", "ä"}, "--"},
    }
}

func TestFieldCanonicalName(t *testing.T) {
    for j, tc := range CasesFieldCanonicalName() {
        if canonicalName := tc.Field.CanonicalName(); canonicalName != tc.CanonicalName {
            t.Errorf(
                "CasesFieldCanonicalName()[%d]: (Field{%q, %q}).CanonicalName() == %q != %q",
                j,
                tc.Field.Name, tc.Field.Body,
                canonicalName, tc.CanonicalName,
            )
        }
    }
}