func (iter *packfileIter) ForEach(cb func(plumbing.EncodedObject) error) error {
	return nil
}
ForEach is never called since is used inside of a MultiObjectIterator
package filesystem
import (
	"io"
	"os"
	"time"
	"gopkg.in/src-d/go-git.v4/plumbing"
	"gopkg.in/src-d/go-git.v4/plumbing/cache"
	"gopkg.in/src-d/go-git.v4/plumbing/format/idxfile"
	"gopkg.in/src-d/go-git.v4/plumbing/format/objfile"
	"gopkg.in/src-d/go-git.v4/plumbing/format/packfile"
	"gopkg.in/src-d/go-git.v4/plumbing/storer"
	"gopkg.in/src-d/go-git.v4/storage/filesystem/internal/dotgit"
	"gopkg.in/src-d/go-git.v4/storage/memory"
	"gopkg.in/src-d/go-git.v4/utils/ioutil"
	"gopkg.in/src-d/go-billy.v4"
)
const DefaultMaxDeltaBaseCacheSize = 92 * cache.MiByte
type ObjectStorage struct {
	DeltaBaseCache cache.Object
	dir   *dotgit.DotGit
	index map[plumbing.Hash]*packfile.Index
}
func newObjectStorage(dir *dotgit.DotGit) (ObjectStorage, error) {
	s := ObjectStorage{
		DeltaBaseCache: cache.NewObjectLRU(DefaultMaxDeltaBaseCacheSize),
		dir:            dir,
	}
	return s, nil
}
func (s *ObjectStorage) requireIndex() error {
	if s.index != nil {
		return nil
	}
	s.index = make(map[plumbing.Hash]*packfile.Index)
	packs, err := s.dir.ObjectPacks()
	if err != nil {
		return err
	}
	for _, h := range packs {
		if err := s.loadIdxFile(h); err != nil {
			return err
		}
	}
	return nil
}
func (s *ObjectStorage) loadIdxFile(h plumbing.Hash) error {
	f, err := s.dir.ObjectPackIdx(h)
	if err != nil {
		return err
	}
	defer ioutil.CheckClose(f, &err)
	idxf := idxfile.NewIdxfile()
	d := idxfile.NewDecoder(f)
	if err = d.Decode(idxf); err != nil {
		return err
	}
	s.index[h] = packfile.NewIndexFromIdxFile(idxf)
	return err
}
func (s *ObjectStorage) NewEncodedObject() plumbing.EncodedObject {
	return &plumbing.MemoryObject{}
}
func (s *ObjectStorage) PackfileWriter() (io.WriteCloser, error) {
	if err := s.requireIndex(); err != nil {
		return nil, err
	}
	w, err := s.dir.NewObjectPack()
	if err != nil {
		return nil, err
	}
	w.Notify = func(h plumbing.Hash, idx *packfile.Index) {
		s.index[h] = idx
	}
	return w, nil
}
func (s *ObjectStorage) SetEncodedObject(o plumbing.EncodedObject) (plumbing.Hash, error) {
	if o.Type() == plumbing.OFSDeltaObject || o.Type() == plumbing.REFDeltaObject {
		return plumbing.ZeroHash, plumbing.ErrInvalidType
	}
	ow, err := s.dir.NewObject()
	if err != nil {
		return plumbing.ZeroHash, err
	}
	defer ioutil.CheckClose(ow, &err)
	or, err := o.Reader()
	if err != nil {
		return plumbing.ZeroHash, err
	}
	defer ioutil.CheckClose(or, &err)
	if err := ow.WriteHeader(o.Type(), o.Size()); err != nil {
		return plumbing.ZeroHash, err
	}
	if _, err := io.Copy(ow, or); err != nil {
		return plumbing.ZeroHash, err
	}
	return o.Hash(), err
}
func (s *ObjectStorage) HasEncodedObject(h plumbing.Hash) (err error) {
	f, err := s.dir.Object(h)
	if err != nil {
		if !os.IsNotExist(err) {
			return err
		}
	} else {
		defer ioutil.CheckClose(f, &err)
		return nil
	}
	if err := s.requireIndex(); err != nil {
		return err
	}
	_, _, offset := s.findObjectInPackfile(h)
	if offset == -1 {
		return plumbing.ErrObjectNotFound
	}
	return nil
}
func (s *ObjectStorage) EncodedObject(t plumbing.ObjectType, h plumbing.Hash) (plumbing.EncodedObject, error) {
	obj, err := s.getFromUnpacked(h)
	if err == plumbing.ErrObjectNotFound {
		obj, err = s.getFromPackfile(h, false)
	}
	if err == plumbing.ErrObjectNotFound {
		dotgits, e := s.dir.Alternates()
		if e == nil {
			for _, dg := range dotgits {
				o, oe := newObjectStorage(dg)
				if oe != nil {
					continue
				}
				enobj, enerr := o.EncodedObject(t, h)
				if enerr != nil {
					continue
				}
				return enobj, nil
			}
		}
	}
	if err != nil {
		return nil, err
	}
	if plumbing.AnyObject != t && obj.Type() != t {
		return nil, plumbing.ErrObjectNotFound
	}
	return obj, nil
}
func (s *ObjectStorage) DeltaObject(t plumbing.ObjectType,
	h plumbing.Hash) (plumbing.EncodedObject, error) {
	obj, err := s.getFromUnpacked(h)
	if err == plumbing.ErrObjectNotFound {
		obj, err = s.getFromPackfile(h, true)
	}
	if err != nil {
		return nil, err
	}
	if plumbing.AnyObject != t && obj.Type() != t {
		return nil, plumbing.ErrObjectNotFound
	}
	return obj, nil
}
func (s *ObjectStorage) getFromUnpacked(h plumbing.Hash) (obj plumbing.EncodedObject, err error) {
	f, err := s.dir.Object(h)
	if err != nil {
		if os.IsNotExist(err) {
			return nil, plumbing.ErrObjectNotFound
		}
		return nil, err
	}
	defer ioutil.CheckClose(f, &err)
	obj = s.NewEncodedObject()
	r, err := objfile.NewReader(f)
	if err != nil {
		return nil, err
	}
	defer ioutil.CheckClose(r, &err)
	t, size, err := r.Header()
	if err != nil {
		return nil, err
	}
	obj.SetType(t)
	obj.SetSize(size)
	w, err := obj.Writer()
	if err != nil {
		return nil, err
	}
	_, err = io.Copy(w, r)
	return obj, err
}
func (s *ObjectStorage) getFromPackfile(h plumbing.Hash, canBeDelta bool) (
	plumbing.EncodedObject, error) {
	if err := s.requireIndex(); err != nil {
		return nil, err
	}
	pack, hash, offset := s.findObjectInPackfile(h)
	if offset == -1 {
		return nil, plumbing.ErrObjectNotFound
	}
	f, err := s.dir.ObjectPack(pack)
	if err != nil {
		return nil, err
	}
	defer ioutil.CheckClose(f, &err)
	idx := s.index[pack]
	if canBeDelta {
		return s.decodeDeltaObjectAt(f, idx, offset, hash)
	}
	return s.decodeObjectAt(f, idx, offset)
}
func (s *ObjectStorage) decodeObjectAt(
	f billy.File,
	idx *packfile.Index,
	offset int64) (plumbing.EncodedObject, error) {
	if _, err := f.Seek(0, io.SeekStart); err != nil {
		return nil, err
	}
	p := packfile.NewScanner(f)
	d, err := packfile.NewDecoder(p, memory.NewStorage())
	if err != nil {
		return nil, err
	}
	d.SetIndex(idx)
	d.DeltaBaseCache = s.DeltaBaseCache
	obj, err := d.DecodeObjectAt(offset)
	return obj, err
}
func (s *ObjectStorage) decodeDeltaObjectAt(
	f billy.File,
	idx *packfile.Index,
	offset int64,
	hash plumbing.Hash) (plumbing.EncodedObject, error) {
	if _, err := f.Seek(0, io.SeekStart); err != nil {
		return nil, err
	}
	p := packfile.NewScanner(f)
	if _, err := p.SeekFromStart(offset); err != nil {
		return nil, err
	}
	header, err := p.NextObjectHeader()
	if err != nil {
		return nil, err
	}
	var (
		base plumbing.Hash
	)
	switch header.Type {
	case plumbing.REFDeltaObject:
		base = header.Reference
	case plumbing.OFSDeltaObject:
		e, ok := idx.LookupOffset(uint64(header.OffsetReference))
		if !ok {
			return nil, plumbing.ErrObjectNotFound
		}
		base = e.Hash
	default:
		return s.decodeObjectAt(f, idx, offset)
	}
	obj := &plumbing.MemoryObject{}
	obj.SetType(header.Type)
	w, err := obj.Writer()
	if err != nil {
		return nil, err
	}
	if _, _, err := p.NextObject(w); err != nil {
		return nil, err
	}
	return newDeltaObject(obj, hash, base, header.Length), nil
}
func (s *ObjectStorage) findObjectInPackfile(h plumbing.Hash) (plumbing.Hash, plumbing.Hash, int64) {
	for packfile, index := range s.index {
		if e, ok := index.LookupHash(h); ok {
			return packfile, e.Hash, int64(e.Offset)
		}
	}
	return plumbing.ZeroHash, plumbing.ZeroHash, -1
}
func (s *ObjectStorage) IterEncodedObjects(t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
	objects, err := s.dir.Objects()
	if err != nil {
		return nil, err
	}
	seen := make(map[plumbing.Hash]bool)
	var iters []storer.EncodedObjectIter
	if len(objects) != 0 {
		iters = append(iters, &objectsIter{s: s, t: t, h: objects})
		seen = hashListAsMap(objects)
	}
	packi, err := s.buildPackfileIters(t, seen)
	if err != nil {
		return nil, err
	}
	iters = append(iters, packi...)
	return storer.NewMultiEncodedObjectIter(iters), nil
}
func (s *ObjectStorage) buildPackfileIters(t plumbing.ObjectType, seen map[plumbing.Hash]bool) ([]storer.EncodedObjectIter, error) {
	if err := s.requireIndex(); err != nil {
		return nil, err
	}
	packs, err := s.dir.ObjectPacks()
	if err != nil {
		return nil, err
	}
	var iters []storer.EncodedObjectIter
	for _, h := range packs {
		pack, err := s.dir.ObjectPack(h)
		if err != nil {
			return nil, err
		}
		iter, err := newPackfileIter(pack, t, seen, s.index[h], s.DeltaBaseCache)
		if err != nil {
			return nil, err
		}
		iters = append(iters, iter)
	}
	return iters, nil
}
type packfileIter struct {
	f billy.File
	d *packfile.Decoder
	t plumbing.ObjectType
	seen     map[plumbing.Hash]bool
	position uint32
	total    uint32
}
func NewPackfileIter(f billy.File, t plumbing.ObjectType) (storer.EncodedObjectIter, error) {
	return newPackfileIter(f, t, make(map[plumbing.Hash]bool), nil, nil)
}
func newPackfileIter(f billy.File, t plumbing.ObjectType, seen map[plumbing.Hash]bool,
	index *packfile.Index, cache cache.Object) (storer.EncodedObjectIter, error) {
	s := packfile.NewScanner(f)
	_, total, err := s.Header()
	if err != nil {
		return nil, err
	}
	d, err := packfile.NewDecoderForType(s, memory.NewStorage(), t)
	if err != nil {
		return nil, err
	}
	d.SetIndex(index)
	d.DeltaBaseCache = cache
	return &packfileIter{
		f: f,
		d: d,
		t: t,
		total: total,
		seen:  seen,
	}, nil
}
func (iter *packfileIter) Next() (plumbing.EncodedObject, error) {
	for {
		if iter.position >= iter.total {
			return nil, io.EOF
		}
		obj, err := iter.d.DecodeObject()
		if err != nil {
			return nil, err
		}
		iter.position++
		if obj == nil {
			continue
		}
		if iter.seen[obj.Hash()] {
			return iter.Next()
		}
		return obj, nil
	}
}