package queue

import (
	"io"
)

type Q chan []byte

type reader struct {
	b []byte
	q Q
}

type writer struct {
	q Q
}

func New() Q {
	return make(Q)
}

func (q Q) Reader() io.Reader {
	return &reader{q: q}
}

func (r *reader) Read(p []byte) (int, error) {
	if len(r.b) == 0 {
		r.b = <-r.q
		if r.b == nil {
			return 0, io.EOF
		}
	}

	n := copy(p, r.b)
	r.b = r.b[n:]

	return n, nil
}

func (r *reader) ReadByte() (byte, error) {
	var b [1]byte

	_, err := r.Read(b[:])

	return b[0], err
}

func (r *reader) WriteTo(w io.Writer) (int64, error) {
	if writer, ok := w.(*writer); ok {
		if len(r.b) > 0 {
			writer.q <- r.b
		}

		return 0, Copy(r.q, writer.q)
	}

	if len(r.b) > 0 {
		if _, err := w.Write(r.b); err != nil {
			return 0, err
		}
	}

	for b := range r.q {
		if _, err := w.Write(b); err != nil {
			return 0, err
		}
	}

	return 0, nil
}

func (q Q) Writer() io.Writer {
	return &writer{q: q}
}

func (q Q) Dry() {
	for _ = range q {
	}
}

func (w *writer) Write(p []byte) (int, error) {
	buf := make([]byte, len(p))
	copy(buf, p)
	w.q <- buf

	return len(p), nil
}

func IoCopy(r io.Reader, w io.Writer) error {
	if _, err := io.Copy(w, r); err != nil {
		if err != io.EOF {
			return err
		}
	}

	return nil
}

func Copy(rq, wq Q) error {
	for b := range rq {
		wq <- b
	}
	return nil
}