// Copyright 2011 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

package norm

import "io"

type normWriter struct {

	rb  reorderBuffer

	w   io.Writer

	buf []byte

}

// Write implements the standard write interface.  If the last characters are

// not at a normalization boundary, the bytes will be buffered for the next

// write. The remaining bytes will be written on close.

func (w *normWriter) Write(data []byte) (n int, err error) {

	// Process data in pieces to keep w.buf size bounded.

	const chunk = 4000

	for len(data) > 0 {

		// Normalize into w.buf.

		m := len(data)

		if m > chunk {

			m = chunk

		}

		w.rb.src = inputBytes(data[:m])

		w.rb.nsrc = m

		w.buf = doAppend(&w.rb, w.buf, 0)

		data = data[m:]

		n += m

		// Write out complete prefix, save remainder.

		// Note that lastBoundary looks back at most 31 runes.

		i := lastBoundary(&w.rb.f, w.buf)

		if i == -1 {

			i = 0

		}

		if i > 0 {

			if _, err = w.w.Write(w.buf[:i]); err != nil {

				break

			}

			bn := copy(w.buf, w.buf[i:])

			w.buf = w.buf[:bn]

		}

	}

	return n, err

}

// Close forces data that remains in the buffer to be written.

func (w *normWriter) Close() error {

	if len(w.buf) > 0 {

		_, err := w.w.Write(w.buf)

		if err != nil {

			return err

		}

	}

	return nil

}

// Writer returns a new writer that implements Write(b)

// Calling its Close method writes any buffered data to w.

func (f Form) Writer(w io.Writer) io.WriteCloser {

	wr := &normWriter{rb: reorderBuffer{}, w: w}

	wr.rb.init(f, nil)

	return wr

}

type normReader struct {

	rb           reorderBuffer

	r            io.Reader

	inbuf        []byte

	outbuf       []byte

	bufStart     int

	lastBoundary int

	err          error

}

// Read implements the standard read interface.

func (r *normReader) Read(p []byte) (int, error) {

	for {

		if r.lastBoundary-r.bufStart > 0 {

			n := copy(p, r.outbuf[r.bufStart:r.lastBoundary])

			r.bufStart += n

			if r.lastBoundary-r.bufStart > 0 {

				return n, nil

			}

			return n, r.err

		}

		if r.err != nil {

			return 0, r.err

		}

		outn := copy(r.outbuf, r.outbuf[r.lastBoundary:])

		r.outbuf = r.outbuf[0:outn]

		r.bufStart = 0

		n, err := r.r.Read(r.inbuf)

		r.rb.src = inputBytes(r.inbuf[0:n])

		r.rb.nsrc, r.err = n, err

		if n > 0 {

			r.outbuf = doAppend(&r.rb, r.outbuf, 0)

		}

		if err == io.EOF {

			r.lastBoundary = len(r.outbuf)

		} else {

			r.lastBoundary = lastBoundary(&r.rb.f, r.outbuf)

			if r.lastBoundary == -1 {

				r.lastBoundary = 0

			}

		}

	}

}

// Reader returns a new reader that implements Read

// by reading data from r and returning f(data).

func (f Form) Reader(r io.Reader) io.Reader {

	const chunk = 4000

	buf := make([]byte, chunk)

	rr := &normReader{rb: reorderBuffer{}, r: r, inbuf: buf}

	rr.rb.init(f, buf)

	return rr

}