package archive

import (
	"archive/tar"
	"path/filepath"

	"fmt"
	"io"
	"os"
)

type Archive struct {
	Output, Input string
	file          *os.File
	writer        *tar.Writer
}

func (a *Archive) Tar() error {
	var err error
	if a.file, err = os.Create(a.Output); err != nil {
		return err
	}

	defer a.file.Close()

	a.writer = tar.NewWriter(a.file)
	defer a.writer.Close()

	if err := filepath.Walk(a.Input, a.tarWalkfn()); err != nil {
		return err
	}

	fmt.Fprintln(os.Stderr, "done, remove me later")
	return nil

}

func (a *Archive) tarWalkfn() filepath.WalkFunc {
	// This is an interesting trick to get around scoping issues
	return func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		if info.IsDir() {
			return nil
		}
		// fmt.Fprintf(os.Stderr, "%s: Fileinfo: %s", path, info.IsDir())

		f, err := os.Open(path)
		if err != nil {
			return err
		}
		// defer f.Close()

		h := &tar.Header{
			Name:    path,
			Size:    info.Size(),
			Mode:    int64(info.Mode()),
			ModTime: info.ModTime(),
		}

		// h, err := tar.FileInfoHeader(info, "")
		if err != nil {
			return err
		}

		err = a.writer.WriteHeader(h)
		if err != nil {
			/*
				fmt.Fprintf(os.Stderr, "This header has a problem: %s\n", h)
				fmt.Fprintln(os.Stderr, "FUCK this error")
				fmt.Fprintln(os.Stderr, err)
			*/
			// fmt.Fprintln(os.Stderr, "Here!")
			return err
		}

		_, err = io.Copy(a.writer, f)
		if err != nil {
			fmt.Fprintln(os.Stderr, "here")
			fmt.Fprintln(os.Stderr, f.Name())
			return err
		}

		return nil
	}
}