package text_test

import (
    "bytes"
    "io"
    "strings"
    "testing"

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

var tests = map[string]string{
    "": "",
    "x": "x\r\n",
    "x\ry": "x\r\ny\r\n",
    "x\nü": "x\r\nü\r\n",
    "0000000000000000000000000000000000000\r0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\r0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\r0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000": "0000000000000000000000000000000000000\r\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\r\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\r\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\r\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\r\n",
}

func TestMappedReader(t *testing.T) {
    for have, want := range tests {
        got, err := io.ReadAll(text.Map(text.Crlf(), text.Map(text.NoNUL(), strings.NewReader(have))))
        if err != nil {
            t.Errorf("%q -> %v", have, err)
        }
        if string(got) != want {
            t.Errorf("%q -> %q != %q", have, got, want)
        }
    }
}

func FuzzMappedReader(f *testing.F) {
    for have := range tests {
        f.Add([]byte(have))
    }

    f.Fuzz(func(t *testing.T, data []byte) {
        normalised, err := io.ReadAll(text.Map(text.Crlf(), text.Map(text.NoNUL(), bytes.NewReader(data))))
        if err != nil {
            t.Errorf("cannot normalise %q: %v", data, err)
        }

        if len(data) == 0 {
            if len(normalised) != 0 {
                t.Errorf("normalised %q into %q: inventive", data, normalised)
            }
            return
        }

/*
        if !utf8.Valid(normalised) {
            t.Errorf("normalised %q into %q: improper UTF-8", data, normalised)
        }
*/
        for j := 0; j < len(normalised); j++ {
            switch normalised[j] {
            case '\r':
                if j >= len(normalised)-1 || normalised[j+1] != '\n' {
                    t.Errorf("normalised %q into %q: improper CRLF sequence", data, normalised)
                }
            case '\n':
                if j <= 0 || normalised[j-1] != '\r' {
                    t.Errorf("normalised %q into %q: improper CRLF sequence", data, normalised)
                }
            case '\x00':
                t.Errorf("normalised %q into %q: contains NUL", data, normalised)
            }
        }
        if !bytes.HasSuffix(normalised, []byte("\r\n")) {
            t.Errorf("normalised %q into %q: does not end in CRLF", data, normalised)
        }
    })
}