package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"os/exec"
	"path/filepath"
	"runtime"
	"strconv"
	"strings"
	"time"

	"lib/statusline"
)

//#include <unistd.h>
import "C"

var arg_max = int(C.sysconf(C._SC_ARG_MAX))

func errhandle(err error) {
	if err != nil {
		panic(err)
	}
}

func myStatusLine() statusline.StatusLine {
	return statusline.StopWatch(statusline.RateLimit(statusline.New(os.Stderr), time.Second/2), time.Second)
}

func getFiemaps(paths []string) map[string][]string {
	var err error
	for i := range paths {
		paths[i], err = filepath.Abs(paths[i])
		errhandle(err)
	}

	ret := map[string][]string{}

	sl := myStatusLine()
	cnt := 0
	sl.Put("Mapping extents...")

	cmd := exec.Command("find", append(paths, "-type", "f", "-exec", "./cow-extent-map", "-m", "--", "{}", "+")...)
	stdout, err := cmd.StdoutPipe()
	errhandle(err)
	cmd.Stderr = os.Stderr

	errhandle(cmd.Start())
	rd := bufio.NewReader(stdout)
	for {
		// read filename
		filename, err := rd.ReadString('\x00')
		if filename == "" && err == io.EOF {
			break
		}
		errhandle(err)
		filename = strings.TrimSuffix(filename, "\x00")
		if !strings.HasPrefix(filename, "/") {
			panic("ugly filename")
		}
		// read extents
		fiemap, err := rd.ReadString('\x00')
		errhandle(err)
		fiemap = strings.TrimSuffix(fiemap, "\x00")
		if !(strings.HasPrefix(fiemap, "logical=") || fiemap == "") {
			panic("ugly fiemap")
		}
		// do stuff
		ret[fiemap] = append(ret[fiemap], filename)
		cnt++
		sl.Put(fmt.Sprintf("Mapping extents... %d", cnt))
	}
	/*errhandle(*/ cmd.Wait() /*)*/

	sl.Put(fmt.Sprintf("Mapping extents... done; mapped %d files", cnt))
	sl.End(true)
	return ret
}

func getChecksums(sl statusline.StatusLine, slfmt string, basecmd []string, paths []string) map[string][]string {
	ret := map[string][]string{}

	cnt := 0
	sl.Put(fmt.Sprintf(slfmt, cnt, len(paths)))

	pathsTodo := paths
	for len(pathsTodo) > 0 {
		pathsDoing := pathsTodo
		arg_len := 0
		for i := range pathsDoing {
			arg_len += len(pathsDoing[i]) + 1
			if arg_len > arg_max/2 {
				pathsDoing = pathsDoing[:i-1]
				break
			}
		}
		pathsTodo = pathsTodo[len(pathsDoing):]

		cmd := exec.Command(basecmd[0], append(basecmd[1:], pathsDoing...)...)
		stdout, err := cmd.StdoutPipe()
		errhandle(err)
		cmd.Stderr = os.Stderr
		errhandle(cmd.Start())
		rd := bufio.NewReader(stdout)
		for {
			line, err := rd.ReadString('\n')
			if line == "" && err == io.EOF {
				break
			}
			errhandle(err)
			parts := strings.SplitN(strings.TrimSuffix(line, "\n"), " ", 2)
			if len(parts) != 2 {
				panic("wut")
			}
			checksum := parts[0]
			filename := strings.TrimPrefix(parts[1], " ")

			ret[checksum] = append(ret[checksum], filename)
			cnt++
			sl.Put(fmt.Sprintf(slfmt, cnt, len(paths)))
		}
		/*errhandle(*/ cmd.Wait() /*)*/
	}

	sl.Put(fmt.Sprintf(slfmt, "done", cnt))
	return ret
}

func pruneSingles(key2vals map[string][]string) {
	for key, vals := range key2vals {
		if len(vals) < 2 {
			delete(key2vals, key)
		}
	}
}

func dedupe(srcFile string, dupFiles []string) error {
	stat, err := os.Stat(srcFile)
	errhandle(err)
	args := []string{
		"-r", "--", strconv.FormatInt(stat.Size(), 10),
		srcFile, "0",
	}
	for _, dupFile := range dupFiles {
		args = append(args, dupFile, "0")
	}

	cmd := exec.Command("./cow-dedupe-range", args...)
	cmd.Stdout = os.Stdout
	cmd.Stderr = os.Stderr
	//fmt.Println("#", checksum)
	//fmt.Println(cmd.Args)
	return cmd.Run()
}

// [ 0s ] size-set[n/d]->c :: sha256-set[t+n/d]->c :: (summed=n deduped=n) :: verb[m/n]
type fancyStatus struct {
	sizeN, sizeD, sizeC    int
	sumT, sumN, sumD, sumC int
	summed, deduped, errs  int
	verb                   string
}

func (s fancyStatus) String() string {
	return fmt.Sprintf("size-set[%d/%d]->%d :: sha256-set[%d+%d/%d]->%d :: (sum=%d dedup=%d err=%d) :: %s",
		s.sizeN, s.sizeD, s.sizeC,
		s.sumT, s.sumN, s.sumD, s.sumC,
		s.summed, s.deduped, s.errs,
		s.verb)
}

func main() {
	// we have low parallelism, don't let syscalls fan-out weird
	// on many-core systems
	runtime.GOMAXPROCS(2)

	fiemap2filenames := getFiemaps(os.Args[1:])

	sl := statusline.StopWatch(statusline.New(os.Stderr), time.Second)
	sl.Put("Building list of spanning files...")

	filename2fiemap := map[string]string{}
	for fiemap, filenames := range fiemap2filenames {
		for _, filename := range filenames {
			if _, ok := filename2fiemap[filename]; ok {
				panic("not ok")
			}
			filename2fiemap[filename] = fiemap
		}
	}

	spanningFiles := make([]string, len(fiemap2filenames))
	i := 0
	for _, filenames := range fiemap2filenames {
		spanningFiles[i] = filenames[0]
		i++
	}

	sl.Put(fmt.Sprintf("Building list of spanning files... done; %d files", len(spanningFiles)))
	sl.End(true)

	sl = myStatusLine()
	size2filenames := getChecksums(sl, "Getting sizes for files... %v/%v",
		[]string{"stat", "--printf=%s  %n\\n", "--"}, spanningFiles)
	sl.End(true)

	fmt.Fprintf(os.Stderr, " -> %d sets", len(size2filenames))
	pruneSingles(size2filenames)
	fmt.Fprintf(os.Stderr, " -> %d non-trivial sets\n", len(size2filenames))

	sl = myStatusLine()
	var status fancyStatus
	status.sizeD = len(size2filenames)
	for _, filenames := range size2filenames {
		status.sizeC = len(filenames)
		// Now do strict hashing, instead of the incredibly
		// sloppy (but fast) size-bucketing.
		status.verb = "sha256sum[%v/%v]"
		checksum2filenames := getChecksums(sl, status.String(), []string{"sha256sum", "--"}, filenames)
		status.summed += len(filenames)
		status.verb = "pruneSingles"
		sl.Put(status.String())
		pruneSingles(checksum2filenames)
		// And loop over the smaller, precise buckets
		status.sumD = len(checksum2filenames)
		for _, filenames := range checksum2filenames {
			status.sumC = len(filenames)
			status.verb = "prep"
			sl.Put(status.String())
			var fiemaps []string
			for _, filename := range filenames {
				fiemaps = append(fiemaps, filename2fiemap[filename])
			}
			// Now we choose the fiemap with the fewest extents
			minFiemap := fiemaps[0]
			minFiemapLen := strings.Count(minFiemap, "\n")
			for _, fiemap := range fiemaps {
				fiemapLen := strings.Count(fiemap, "\n")
				if fiemapLen < minFiemapLen {
					minFiemap = fiemap
					minFiemapLen = fiemapLen
				}
			}
			// Set srcFile and dupFiles based on that
			srcFile := fiemap2filenames[minFiemap][0]
			var dupFiles []string
			for _, fiemap := range fiemaps {
				if fiemap == minFiemap {
					continue
				}
				dupFiles = append(dupFiles, fiemap2filenames[fiemap]...)
			}
			// And actually dedupe those
			name := filepath.Base(srcFile)
			if len(name) > 21 {
				name = name[:20] + "…"
			}
			status.verb = fmt.Sprintf("dedupe %q (and %d more)", name, len(dupFiles))
			sl.Put(status.String())
			err := dedupe(srcFile, dupFiles)
			if err != nil {
				status.errs++
			} else {
				status.deduped++
			}
			status.sumN++
		}
		status.sumT += len(checksum2filenames)
		status.sumN = 0
		status.sumD = 0
		status.sumC = 0
		status.sizeN++
	}
	status.verb = "done"
	sl.Put(status.String())
	sl.End(true)
}