package main

import (
	"archive/tar"
	"compress/bzip2"
	"compress/gzip"
	"errors"
	"flag"
	"fmt"
	"io"
	"os"
	"path/filepath"

	"github.com/kisom/goutils/die"
)

var (
	preserveOwners bool
	preserveMode bool
	verbose bool
)

func setupFile(hdr *tar.Header, file *os.File) error {
	if preserveMode {
		if verbose {
			fmt.Printf("\tchmod %0#o\n", hdr.Mode)
		}
		err := file.Chmod(os.FileMode(hdr.Mode))
		if err != nil {
			return err
		}
	}
	
	if preserveOwners {
		fmt.Printf("\tchown %d:%d\n", hdr.Uid, hdr.Gid)
		err := file.Chown(hdr.Uid, hdr.Gid)
		if err != nil {
			return err
		}
	}

	return nil
}

func linkTarget(target, top string) string {
	if filepath.IsAbs(target) {
		return target
	}

	return filepath.Clean(filepath.Join(target, top))
}

func processFile(tfr *tar.Reader, hdr *tar.Header, top string) error {
	if verbose {
		fmt.Println(hdr.Name)
	}
	filePath := filepath.Clean(filepath.Join(top, hdr.Name))
	switch hdr.Typeflag {
	case tar.TypeReg, tar.TypeRegA:
		file, err := os.Create(filePath)
		if err != nil {
			return err
		}

		_, err = io.Copy(file, tfr)
		if err != nil {
			return err
		}

		err = setupFile(hdr, file)
		if err != nil {
			return err
		}
	case tar.TypeLink:
		file, err := os.Create(filePath)
		if err != nil {
			return err
		}

		source, err := os.Open(hdr.Linkname)
		if err != nil {
			return err
		}

		_, err = io.Copy(file, source)
		if err != nil {
			return err
		}

		err = setupFile(hdr, file)
		if err != nil {
			return err
		}
	case tar.TypeSymlink:
		err := os.Symlink(linkTarget(hdr.Linkname, top), filePath)
		if err != nil {
			return err
		}
	case tar.TypeDir:
		err := os.MkdirAll(filePath, os.FileMode(hdr.Mode))
		if err != nil {
			return err
		}
	}

	return nil
}

var compression = map[string]bool{
	"gzip":  false,
	"bzip2": false,
}

type bzipCloser struct {
	r io.Reader
}

func (brc *bzipCloser) Read(p []byte) (int, error) {
	return brc.r.Read(p)
}

func (brc *bzipCloser) Close() error {
	return nil
}

func newBzipCloser(r io.ReadCloser) (io.ReadCloser, error) {
	br := bzip2.NewReader(r)
	return &bzipCloser{r: br}, nil
}

var compressFuncs = map[string]func(io.ReadCloser) (io.ReadCloser, error){
	"gzip":  func(r io.ReadCloser) (io.ReadCloser, error) { return gzip.NewReader(r) },
	"bzip2": newBzipCloser,
}

func verifyCompression() bool {
	var compressed bool
	for _, v := range compression {
		if compressed && v {
			return false
		}
		compressed = compressed || v
	}
	return true
}

func getReader(r io.ReadCloser) (io.ReadCloser, error) {
	for c, v := range compression {
		if v {
			return compressFuncs[c](r)
		}
	}

	return r, nil
}

func openArchive(path string) (io.ReadCloser, error) {
	file, err := os.Open(path)
	if err != nil {
		return nil, err
	}

	r, err := getReader(file)
	if err != nil {
		return nil, err
	}

	return r, nil
}

var compressFlags struct {
	z bool
	j bool
}

func parseCompressFlags() error {
	if compressFlags.z {
		compression["gzip"] = true
	}

	if compressFlags.j {
		compression["bzip2"] = true
	}

	if !verifyCompression() {
		return errors.New("multiple compression formats specified")
	}

	return nil
}

func usage(w io.Writer) {
	fmt.Fprintf(w, `ChromeOS untar

This is a tool that is intended to support untarring on SquashFS file
systems. In particular, every time it encounters a hard link, it
will just create a copy of the file.

Usage: cruntar [-jmvpz] archive [dest]

Flags:
	-a	Shortcut for -m -p: preserve owners and file mode.
	-j	The archive is compressed with bzip2.
	-m	Preserve file modes.
	-p	Preserve ownership.
	-v	Print the name of each file as it is being processed.
	-z	The archive is compressed with gzip.
`)
}

func init() {
	flag.Usage = func() { usage(os.Stderr) }
}

func main() {
	var archive, help bool
	flag.BoolVar(&archive, "a", false, "Shortcut for -m -p: preserve owners and file mode.")
	flag.BoolVar(&help, "h", false, "print a help message")
	flag.BoolVar(&compressFlags.j, "j", false, "bzip2 compression")
	flag.BoolVar(&preserveMode, "m", false, "preserve file modes")
	flag.BoolVar(&preserveOwners, "p", false, "preserve ownership")
	flag.BoolVar(&verbose, "v", false, "verbose mode")
	flag.BoolVar(&compressFlags.z, "z", false, "gzip compression")
	flag.Parse()

	if help {
		usage(os.Stdout)
		os.Exit(0)
	}
	
	if archive {
		preserveMode = true
		preserveOwners = true
	}

	err := parseCompressFlags()
	die.If(err)

	if flag.NArg() == 0 {
		return
	}

	top := "./"
	if flag.NArg() > 1 {
		top = flag.Arg(1)
	}

	r, err := openArchive(flag.Arg(0))
	die.If(err)

	tfr := tar.NewReader(r)
	for {
		hdr, err := tfr.Next()
		if err == io.EOF {
			break
		}
		die.If(err)

		err = processFile(tfr, hdr, top)
		die.If(err)

	}

	r.Close()
}