package main

import (
	"bufio"
	"flag"
	"fmt"
	"io"
	"os"
	"runtime"
	"strconv"
	"strings"
	"sync"

	"github.com/OneOfOne/xxhash"
)

var (
	mux      sync.Mutex
	errored  bool
	use32    = flag.Bool("32", false, "use 32bit hash instead of 64bit")
	checkArg = flag.Bool("c", false, "read and check the sums of input files")
	seedArg  = flag.Uint64("s", 0, "use `seed` to seed the hasher")
)

func init() {
	flag.Parse()
	flag.Usage = func() {
		errorf("Usage of %s: [-32] [-c] [-s seed] files...\t%s *.go > sums.xx\t%s -c sums.xx", os.Args[0], os.Args[0], os.Args[0])
		flag.PrintDefaults()
		os.Exit(1)
	}
}

func main() {
	args := flag.Args()
	st, _ := os.Stdin.Stat()
	if st.Mode()&os.ModeCharDevice == 0 {
		args = append(args, "-")
	}
	if len(args) == 0 {
		flag.Usage()
	}
	sema := newSema(runtime.NumCPU())
	var wg sync.WaitGroup
	wg.Add(len(args))
	if !*checkArg {
		printf("# seed %d", *seedArg)
		if *use32 {
			printf("# 32bit")
		} else {
			printf("# 64bit")
		}
	}
	for _, fn := range args {
		if *checkArg {
			check(newSema(runtime.NumCPU()), fn)
		} else {
			sema.Run(func() { printHash(fn) })
		}
	}
	sema.WaitAndClose()
	if errored {
		os.Exit(1)
	}
}

func check(sema *sema, fn string) {
	defer sema.WaitAndClose()
	var err error
	var f *os.File
	if fn == "-" {
		f = os.Stdin
	} else {
		if f, err = os.Open(fn); err != nil {
			errorf("error opening %s: %v", fn, err)
			return
		}
		defer f.Close()
	}
	buf := bufio.NewScanner(f)
	for buf.Scan() {
		ln := strings.TrimSpace(buf.Text())
		if len(ln) == 0 {
			continue
		}
		if strings.HasPrefix(ln, "# seed ") {
			*seedArg, _ = strconv.ParseUint(strings.TrimSpace(ln[7:]), 10, 64)
			continue
		}
		if strings.HasPrefix(ln, "# 32bit") {
			*use32 = true
			continue
		}
		if strings.HasPrefix(ln, "# 64bit") {
			*use32 = false
			continue
		}
		if ln[0] == '#' {
			continue
		}
		parts := strings.SplitN(ln, "\t", 2)
		if len(parts) != 2 || len(parts[0]) < 1 {
			continue
		}
		oh, err := strconv.ParseUint(strings.TrimSpace(parts[0]), 10, 64)
		if err != nil {
			errorf("error: %v", err)
			continue
		}
		sema.Run(func() {
			fn := strings.TrimSpace(parts[1])
			nh, err := hashFile(fn)
			if err != nil {
				errorf("error hashing %s: %v", fn, err)
			}
			if oh != nh {
				errorf("hash mismatch %q 0x%X 0x%X", fn, oh, nh)
			}
		})
	}
}

func printHash(fn string) {
	h, err := hashFile(fn)
	if err != nil {
		errorf("error hashing %s: %v", fn, err)
		return
	}
	if h == 0 {
		return
	}
	if *use32 {
		printf("%-10d\t%s", h, fn)
	} else {
		printf("%-20d\t%s", h, fn)
	}
}

func hashFile(fn string) (h uint64, err error) {
	var f *os.File
	if fn == "-" {
		f = os.Stdin
	} else {
		if f, err = os.Open(fn); err != nil {
			return
		}
		defer f.Close()
		if st, _ := f.Stat(); st.IsDir() || st.Size() == 0 {
			return
		}
	}
	if *use32 {
		xx := xxhash.NewS32(uint32(*seedArg))
		if _, err = io.Copy(xx, f); err != nil {
			return
		}
		return uint64(xx.Sum32()), nil
	}
	xx := xxhash.NewS64(*seedArg)
	if _, err = io.Copy(xx, f); err != nil {
		return
	}
	return xx.Sum64(), nil
}

func printf(f string, args ...interface{}) {
	mux.Lock()
	fmt.Fprintf(os.Stdout, f+"\n", args...)
	mux.Unlock()
}

func errorf(f string, args ...interface{}) {
	mux.Lock()
	fmt.Fprintf(os.Stderr, f+"\n", args...)
	errored = true
	mux.Unlock()
}