package objfile

import (
	"errors"
	"io"

	"gopkg.in/src-d/go-git.v4/core"

	"github.com/klauspost/compress/zlib"
)

var (
	// ErrZLib is returned when the objfile contains invalid zlib data.
	ErrZLib = errors.New("objfile: invalid zlib data")
)

// Reader reads and decodes compressed objfile data from a provided io.Reader.
//
// Reader implements io.ReadCloser. Close should be called when finished with
// the Reader. Close will not close the underlying io.Reader.
type Reader struct {
	header header
	hash   core.Hash // final computed hash stored after Close

	r            io.Reader     // provided reader wrapped in decompressor and tee
	decompressor io.ReadCloser // provided reader wrapped in decompressor, retained for calling Close
	h            core.Hasher   // streaming SHA1 hash of decoded data
}

// NewReader returns a new Reader reading from r.
//
// Calling NewReader causes it to immediately read in header data from r
// containing size and type information. Any errors encountered in that
// process will be returned in err.
//
// The returned Reader implements io.ReadCloser. Close should be called when
// finished with the Reader. Close will not close the underlying io.Reader.
func NewReader(r io.Reader) (*Reader, error) {
	reader := &Reader{}
	return reader, reader.init(r)
}

// init prepares the zlib decompressor for the given input as well as a hasher
// for computing its hash.
//
// init immediately reads header data from the input and stores it. This leaves
// the Reader in a state that is ready to read content.
func (r *Reader) init(input io.Reader) (err error) {
	r.decompressor, err = zlib.NewReader(input)
	if err != nil {
		// TODO: Make this error match the ZLibErr in formats/packfile/reader.go?
		return ErrZLib
	}

	err = r.header.Read(r.decompressor)
	if err != nil {
		r.decompressor.Close()
		return
	}

	r.h = core.NewHasher(r.header.t, r.header.size)
	r.r = io.TeeReader(r.decompressor, r.h) // All reads from the decompressor also write to the hash

	return
}

// Read reads len(p) bytes into p from the object data stream. It returns
// the number of bytes read (0 <= n <= len(p)) and any error encountered. Even
// if Read returns n < len(p), it may use all of p as scratch space during the
// call.
//
// If Read encounters the end of the data stream it will return err == io.EOF,
// either in the current call if n > 0 or in a subsequent call.
func (r *Reader) Read(p []byte) (n int, err error) {
	if r.r == nil {
		return 0, ErrClosed
	}

	return r.r.Read(p)
}

// Type returns the type of the object.
func (r *Reader) Type() core.ObjectType {
	return r.header.t
}

// Size returns the uncompressed size of the object in bytes.
func (r *Reader) Size() int64 {
	return r.header.size
}

// Hash returns the hash of the object data stream that has been read so far.
// It can be called before or after Close.
func (r *Reader) Hash() core.Hash {
	if r.r != nil {
		return r.h.Sum() // Not yet closed, return hash of data read so far
	}
	return r.hash
}

// Close releases any resources consumed by the Reader.
//
// Calling Close does not close the wrapped io.Reader originally passed to
// NewReader.
func (r *Reader) Close() (err error) {
	if r.r == nil {
		// TODO: Consider returning ErrClosed here?
		return nil // Already closed
	}

	// Release the decompressor's resources
	err = r.decompressor.Close()

	// Save the hash because we're about to throw away the hasher
	r.hash = r.h.Sum()

	// Release references
	r.r = nil // Indicates closed state
	r.decompressor = nil
	r.h.Hash = nil

	return
}

// FillObject fills the given object from an object entry
func (r *Reader) FillObject(obj core.Object) error {
	obj.SetType(r.header.t)
	obj.SetSize(r.header.size)
	w, err := obj.Writer()
	if err != nil {
		return err
	}
	_, err = io.Copy(w, r.r)

	return err
}