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 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 := statusline.NewAsyncStatusLine(os.Stderr, time.Second/2)
	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.End()
	fmt.Fprintf(os.Stderr, "Mapping extents... done; mapped %d files\n", cnt)
	return ret
}

func getChecksums(paths []string) map[string][]string {
	ret := map[string][]string{}

	sl := statusline.NewAsyncStatusLine(os.Stderr, time.Second/2)
	cnt := 0
	sl.Put(fmt.Sprintf("Generating checksums for files... %d/%d", cnt, len(paths)))

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

		cmd := exec.Command("sha256sum", append([]string{"--"}, _paths...)...)
		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("Generating checksums for files... %d/%d", cnt, len(paths)))
		}
		errhandle(cmd.Wait())
	}

	sl.End()
	fmt.Fprintf(os.Stderr, "Generating checksums for files... done; summed %d files\n", cnt)
	return ret
}

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:])

	fmt.Fprintf(os.Stderr, "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++
	}

	fmt.Fprintf(os.Stderr, " done\n")
	checksum2filenames := getChecksums(spanningFiles)

	checksum2fiemaps := map[string][]string{}
	for checksum, filenames := range checksum2filenames {
		for _, filename := range filenames {
			checksum2fiemaps[checksum] = append(checksum2fiemaps[checksum], filename2fiemap[filename])
		}
	}
	for checksum, fiemaps := range checksum2fiemaps {
		if len(fiemaps) < 2 {
			delete(checksum2fiemaps, checksum)
		}
	}

	fmt.Fprintf(os.Stderr, "Deduplicating %d sets of files...\n", len(checksum2fiemaps))
	for checksum, fiemaps := range checksum2fiemaps {
		// 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
			}
		}
		srcFile := fiemap2filenames[minFiemap][0]
		var dupFiles []string
		for _, fiemap := range fiemaps {
			if fiemap == minFiemap {
				continue
			}
			dupFiles = append(dupFiles, fiemap2filenames[fiemap]...)
		}

		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)
		errhandle(cmd.Run())
	}
}