//   .-.   .-.
//   | |   | |
//   | `--.| `--.
//   `----'`----'
//
// ll – a small utility to list files in the current directory.
//
// # Why?
// Because I wanted to display files in columns with git status.
//
// # Rationalize
// One entry per line for lots of files can't be fitted on a screen
// and requires scrolling. With the multi-column layout, space can be
// used more efficiently. At the same time, git status information is
// also often needed.

package main

import (
	"bytes"
	"fmt"
	"io/ioutil"
	"math"
	"os"
	"os/exec"
	"path/filepath"
	. "strings"
	"sync"
	"time"

	"golang.org/x/sys/unix"
)

const (
	modified  = "\033[0;34m%s\033[0m"
	added     = "\033[0;32m%s\033[0m"
	untracked = "\033[0;31m%s\033[0m"
	bold      = "\033[1m%v\033[0m"
)

var (
	spinner = []string{"⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"}
	sizes   = []string{"B", "kB", "MB", "GB", "TB", "PB", "EB"}
	base    = float64(1000)
)

func main() {
	if len(os.Args) == 2 {
		ll(os.Args[1])
		return
	}

	if len(os.Args) > 2 {
		for i := 1; i < len(os.Args); i++ {
			path, _ := filepath.Abs(os.Args[i])
			printInfo(fileInfo(path), path)
		}
		return
	}

	pwd, err := os.Getwd()
	if err != nil {
		panic(err)
	}
	ll(pwd)
}

func ll(cwd string) {
	// Maybe it is and argument, so get absolute path.
	cwd, _ = filepath.Abs(cwd)

	// Is it a file?
	if fi := fileInfo(cwd); !fi.IsDir() {
		printInfo(fi, cwd)
		return
	}

	// ReadDir already returns files and dirs sorted by filename.
	files, err := ioutil.ReadDir(cwd)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	if len(files) == 0 {
		return
	}

	// We need terminal size to nicely fit on screen.
	var width, height int
	ws, err := unix.IoctlGetWinsize(int(os.Stdout.Fd()), unix.TIOCGWINSZ)
	if err != nil || ws == nil {
		width, height = 80, 60
	} else {
		width, height = int(ws.Col), int(ws.Row)
	}

	// If it's possible to fit all files in one column on half of screen, just use one column.
	// Otherwise let's squeeze listing in half of screen.
	columns := len(files)/(height/2) + 1

	// Gonna keep file names and format string for git status.
	modes := map[string]string{}

	// If stdout of ll piped, use ls behavior: one line, no colors.
	fi, err := os.Stdout.Stat()
	if err != nil {
		panic(err)
	}
	if (fi.Mode() & os.ModeCharDevice) == 0 {
		columns = 1
	} else {
		status := gitStatus()
		for _, file := range files {
			name := file.Name()
			if file.IsDir() {
				name += "/"
			}
			// gitStatus returns file names of modified files from repo root.
			fullPath := filepath.Join(cwd, name)
			for path, mode := range status {
				if subPath(path, fullPath) {
					if mode[0] == '?' || mode[1] == '?' {
						modes[name] = untracked
					} else if mode[0] == 'A' || mode[1] == 'A' {
						modes[name] = added
					} else if mode[0] == 'M' || mode[1] == 'M' {
						modes[name] = modified
					}
				}
			}
		}
	}

start:
	// Let's try to fit everything in terminal width with this many columns.
	// If we are not able to do it, decrease column number and goto start.
	rows := int(math.Ceil(float64(len(files)) / float64(columns)))
	names := make([][]string, columns)
	n := 0
	for i := 0; i < columns; i++ {
		names[i] = make([]string, rows)
		// Columns size is going to be of max file name size.
		max := 0
		for j := 0; j < rows; j++ {
			name := ""
			if n < len(files) {
				name = files[n].Name()
				if files[n].IsDir() {
					// Dir should have slash at end.
					name += "/"
				}
				n++
			}
			if max < len(name) {
				max = len(name)
			}
			names[i][j] = name
		}
		// Append spaces to make all names in one column of same size.
		for j := 0; j < rows; j++ {
			names[i][j] += Repeat(" ", max-len(names[i][j]))
		}
	}

	const separator = "    " // Separator between columns.
	for j := 0; j < rows; j++ {
		row := make([]string, columns)
		for i := 0; i < columns; i++ {
			row[i] = names[i][j]
		}
		if len(Join(row, separator)) > width && columns > 1 {
			// Yep. No luck, let's decrease number of columns and try one more time.
			columns--
			goto start
		}
	}

	// Let's add colors from git status to file names.
	output := make([]string, rows)
	for j := 0; j < rows; j++ {
		row := make([]string, columns)
		for i := 0; i < columns; i++ {
			f, ok := modes[TrimRight(names[i][j], " ")]
			if !ok {
				f = "%s"
			}
			row[i] = fmt.Sprintf(f, names[i][j])
		}
		output[j] = Join(row, separator)
	}
	fmt.Println(Join(output, "\n"))
}

func subPath(path string, fullPath string) bool {
	p := Split(path, "/")
	for i, s := range Split(fullPath, "/") {
		if i >= len(p) {
			return false
		}
		if p[i] != s {
			return false
		}
	}
	return true
}

func gitRepo() (string, error) {
	cmd := exec.Command("git", "rev-parse", "--show-toplevel")
	var out bytes.Buffer
	cmd.Stdout = &out
	err := cmd.Run()
	return Trim(out.String(), "\n"), err
}

func gitStatus() map[string]string {
	repo, err := gitRepo()
	if err != nil {
		return nil
	}
	cmd := exec.Command("git", "status", "--porcelain=v1")
	var out bytes.Buffer
	cmd.Stdout = &out
	err = cmd.Run()
	if err != nil {
		return nil
	}
	m := map[string]string{}
	for _, line := range Split(Trim(out.String(), "\n"), "\n") {
		if len(line) == 0 {
			continue
		}
		m[filepath.Join(repo, line[3:])] = line[:2]
	}
	return m
}

func printInfo(fi os.FileInfo, path string) {
	name := fi.Name()
	size := fi.Size()
	if fi.IsDir() {
		name += "/"
		done := make(chan bool)
		wg := sync.WaitGroup{}
		wg.Add(1)
		go func() {
			defer wg.Done()
			i, t := 0, time.Tick(100*time.Millisecond)
			for {
				select {
				case <-t:
					fmt.Printf("\r%v\t%v", spinner[i%len(spinner)], name)
					i++
				case <-done:
					fmt.Print("\r")
					return
				}
			}
		}()
		size, _ = dirSize(path)
		done <- true
		wg.Wait()
	}
	fmt.Printf("%v\t%v\n", toHuman(size), name)
}

func fileInfo(path string) os.FileInfo {
	fi, err := os.Stat(path)
	if err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
	return fi
}

func toHuman(s int64) string {
	if s < 10 {
		value := fmt.Sprintf(bold, s)
		return fmt.Sprintf("  %v B", value)
	}
	e := math.Floor(math.Log(float64(s)) / math.Log(base))
	suffix := sizes[int(e)]
	val := math.Floor(float64(s)/math.Pow(base, e)*10+0.5) / 10
	f := "%3.0f"
	if val < 10 {
		f = "%3.1f"
	}

	value := fmt.Sprintf(bold, fmt.Sprintf(f, val))
	return fmt.Sprintf("%v %v", value, suffix)
}

func dirSize(path string) (int64, error) {
	var size int64
	err := filepath.Walk(path, func(_ string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}
		if !info.IsDir() {
			size += info.Size()
		}
		return err
	})
	return size, err
}