package gzip

import (
	"bytes"
	"compress/gzip"
	"io"
	"os"

	zipper "git.sa-roci.de/oss/go_zipper"
)

// NewGUnzipper makes a new Unzipper.
func NewGUnzipper(zipFilename string) zipper.Unzipper {
	guz := gUnzipper{
		Unzipper: zipper.NewBaseUnzipper(zipFilename),
	}
	guz.SetDecompressor(&guz)
	return guz
}

type gUnzipper struct {
	zipper.Unzipper
	buffer bytes.Buffer
}

func (guz *gUnzipper) OpenReader(zipFile *os.File) (err error) {
	var reader *gzip.Reader
	guz.buffer = bytes.Buffer{}
	if _, err = io.Copy(&guz.buffer, zipFile); err == nil {
		if reader, err = gzip.NewReader(&guz.buffer); err == nil {
			guz.SetReader(reader)
		}
	}
	return
}

func (guz *gUnzipper) Decompress(targetFolderPathInFileSystem string) (err error) {
	if reader, ok := guz.GetReader().(*gzip.Reader); ok {
		if err = zipper.MakeSurePathExists(targetFolderPathInFileSystem+"/dummy.file", 0644); err == nil {
			for {
				if reader.Name == "" {
					break
				}
				reader.Multistream(false)
				outputPath := zipper.PrependPath(reader.Name, targetFolderPathInFileSystem)
				if err = zipper.MakeSurePathExists(outputPath, 0644); err == nil {
					var dstFile *os.File
					if dstFile, err = os.OpenFile(outputPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0644); err == nil {
						defer dstFile.Close()
						if _, err = io.Copy(dstFile, reader); err == nil {
							if err = reader.Reset(&guz.buffer); err == io.EOF {
								err = nil
								break
							}
						}
					}
				}

				if err != nil {
					break
				}
			}
		}
	}
	return
}