/*
goredo -- djb's redo implementation on pure Go
Copyright (C) 2020-2023 Sergey Matveev <stargrave@stargrave.org>

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, version 3 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

package main

import (
	"bufio"
	"bytes"
	"crypto/rand"
	"errors"
	"flag"
	"fmt"
	"io"
	"log"
	"os"
	"os/signal"
	"path"
	"runtime"
	"sort"
	"strconv"
	"syscall"

	"go.cypherpunks.ru/recfile"
	"golang.org/x/sys/unix"
)

const (
	CmdNameGoredo       = "goredo"
	CmdNameRedo         = "redo"
	CmdNameRedoAffects  = "redo-affects"
	CmdNameRedoAlways   = "redo-always"
	CmdNameRedoCleanup  = "redo-cleanup"
	CmdNameRedoDepFix   = "redo-depfix"
	CmdNameRedoDot      = "redo-dot"
	CmdNameRedoIfchange = "redo-ifchange"
	CmdNameRedoIfcreate = "redo-ifcreate"
	CmdNameRedoInode    = "redo-inode"
	CmdNameRedoLog      = "redo-log"
	CmdNameRedoOOD      = "redo-ood"
	CmdNameRedoSources  = "redo-sources"
	CmdNameRedoStamp    = "redo-stamp"
	CmdNameRedoTargets  = "redo-targets"
	CmdNameRedoWhichdo  = "redo-whichdo"
)

var (
	Cwd       string
	BuildUUID string
	IsTopRedo bool // is it the top redo instance
	UmaskCur  int
)

func mustSetenv(key string) {
	if err := os.Setenv(key, "1"); err != nil {
		panic(err)
	}
}

func mustParseFd(v, name string) *os.File {
	ptr, err := strconv.ParseUint(v, 10, 64)
	if err != nil {
		panic(err)
	}
	fd := os.NewFile(uintptr(ptr), name)
	if fd == nil {
		panic("can not parse fd: " + name)
	}
	return fd
}

func CmdName() string {
	return path.Base(os.Args[0])
}

func main() {
	version := flag.Bool("version", false, "print version")
	warranty := flag.Bool("warranty", false, "print warranty information")

	var symlinks *bool
	cmdName := CmdName()
	if cmdName == "goredo" {
		symlinks = flag.Bool("symlinks", false, "create necessary symlinks in current directory")
	}

	flag.Usage = func() { usage(os.Args[0]) }
	flag.Parse()
	if *warranty {
		fmt.Println(Warranty)
		return
	}
	if *version {
		fmt.Println("goredo", Version, "built with", runtime.Version())
		return
	}
	if cmdName == CmdNameGoredo && *symlinks {
		rc := 0
		for _, cmdName := range []string{
			CmdNameRedo,
			CmdNameRedoAffects,
			CmdNameRedoAlways,
			CmdNameRedoCleanup,
			CmdNameRedoDepFix,
			CmdNameRedoDot,
			CmdNameRedoIfchange,
			CmdNameRedoIfcreate,
			CmdNameRedoInode,
			CmdNameRedoLog,
			CmdNameRedoOOD,
			CmdNameRedoSources,
			CmdNameRedoStamp,
			CmdNameRedoTargets,
			CmdNameRedoWhichdo,
		} {
			fmt.Println(os.Args[0], "<-", cmdName)
			if err := os.Symlink(os.Args[0], cmdName); err != nil {
				rc = 1
				log.Print(err)
			}
		}
		os.Exit(rc)
	}
	log.SetFlags(log.Lshortfile)

	UmaskCur = syscall.Umask(0)
	syscall.Umask(UmaskCur)

	var err error
	Cwd, err = os.Getwd()
	if err != nil {
		log.Fatal(err)
	}

	TopDir = os.Getenv(EnvTopDir)
	if TopDir == "" {
		TopDir = "/"
	} else {
		TopDir = mustAbs(TopDir)
	}
	DirPrefix = os.Getenv(EnvDirPrefix)
	DepCwd = os.Getenv(EnvDepCwd)

	if flagStderrKeep != nil && *flagStderrKeep {
		mustSetenv(EnvStderrKeep)
	}
	if flagStderrSilent != nil && *flagStderrSilent {
		mustSetenv(EnvStderrSilent)
	}
	if flagNoProgress != nil && *flagNoProgress {
		mustSetenv(EnvNoProgress)
	}
	if flagDebug != nil && *flagDebug {
		mustSetenv(EnvDebug)
	}
	if flagLogWait != nil && *flagLogWait {
		mustSetenv(EnvLogWait)
	}
	if flagLogLock != nil && *flagLogLock {
		mustSetenv(EnvLogLock)
	}
	if flagLogPid != nil && *flagLogPid {
		mustSetenv(EnvLogPid)
	}
	if flagLogJS != nil && *flagLogJS {
		mustSetenv(EnvLogJS)
	}
	StderrKeep = os.Getenv(EnvStderrKeep) == "1"
	StderrSilent = os.Getenv(EnvStderrSilent) == "1"
	NoProgress = os.Getenv(EnvNoProgress) == "1"
	Debug = os.Getenv(EnvDebug) == "1"
	LogWait = os.Getenv(EnvLogWait) == "1"
	LogLock = os.Getenv(EnvLogLock) == "1"
	LogJS = os.Getenv(EnvLogJS) == "1"
	if Debug || os.Getenv(EnvLogPid) == "1" {
		MyPid = os.Getpid()
	}
	var traced bool
	if flagTraceAll != nil && *flagTraceAll {
		mustSetenv(EnvTrace)
	}
	if os.Getenv(EnvTrace) == "1" {
		TracedAll = true
		traced = true
	} else if flagTrace != nil {
		traced = *flagTrace
	}
	NoColor = os.Getenv(EnvNoColor) != ""
	NoSync = os.Getenv(EnvNoSync) == "1"
	StopIfMod = os.Getenv(EnvStopIfMod) == "1"
	switch s := os.Getenv(EnvInodeTrust); s {
	case "none":
		InodeTrust = InodeTrustNone
	case "", "ctime":
		InodeTrust = InodeTrustCtime
	case "mtime":
		InodeTrust = InodeTrustMtime
	default:
		log.Fatalln("unknown", EnvInodeTrust, "value")
	}

	// Those are internal envs
	FdOODTgts, err = os.CreateTemp("", "ood-tgts")
	if err != nil {
		log.Fatal(err)
	}
	if err = os.Remove(FdOODTgts.Name()); err != nil {
		log.Fatal(err)
	}
	FdOODTgtsLock, err = os.CreateTemp("", "ood-tgts.lock")
	if err != nil {
		log.Fatal(err)
	}
	if err = os.Remove(FdOODTgtsLock.Name()); err != nil {
		log.Fatal(err)
	}

	var fdLock *os.File
	if v := os.Getenv(EnvOODTgtsFd); v != "" {
		fd := mustParseFd(v, EnvOODTgtsFd)
		fdLock = mustParseFd(v, EnvOODTgtsLockFd)
		defer fdLock.Close()
		flock := unix.Flock_t{
			Type:   unix.F_WRLCK,
			Whence: io.SeekStart,
		}
		if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLKW, &flock); err != nil {
			log.Fatal(err)
		}
		if _, err = fd.Seek(0, io.SeekStart); err != nil {
			log.Fatal(err)
		}
		tgtsRaw, err := io.ReadAll(bufio.NewReader(fd))
		if err != nil {
			log.Fatal(err)
		}
		flock.Type = unix.F_UNLCK
		if err = unix.FcntlFlock(fdLock.Fd(), unix.F_SETLK, &flock); err != nil {
			log.Fatal(err)
		}
		OODTgts = make(map[string]struct{})
		for _, tgtRaw := range bytes.Split(tgtsRaw, []byte{0}) {
			t := string(tgtRaw)
			if t == "" {
				continue
			}
			OODTgts[t] = struct{}{}
			tracef(CDebug, "ood: known to be: %s", t)
		}
	}

	StderrPrefix = os.Getenv(EnvStderrPrefix)
	if v := os.Getenv(EnvLevel); v != "" {
		Level, err = strconv.Atoi(v)
		if err != nil {
			panic(err)
		}
		if Level < 0 {
			panic("negative " + EnvLevel)
		}
	}

	var fdDep *os.File
	if v := os.Getenv(EnvDepFd); v != "" {
		fdDep = mustParseFd(v, EnvDepFd)
	}

	tgts := make([]*Tgt, 0, len(flag.Args()))
	for _, arg := range flag.Args() {
		tgts = append(tgts, NewTgt(arg))
	}
	BuildUUID = os.Getenv(EnvBuildUUID)
	tgtsWasEmpty := len(tgts) == 0
	if BuildUUID == "" {
		IsTopRedo = true
		raw := new([16]byte)
		if _, err = io.ReadFull(rand.Reader, raw[:]); err != nil {
			log.Fatal(err)
		}
		raw[6] = (raw[6] & 0x0F) | uint8(4<<4) // version 4
		BuildUUID = fmt.Sprintf(
			"%x-%x-%x-%x-%x",
			raw[0:4], raw[4:6], raw[6:8], raw[8:10], raw[10:],
		)
		if tgtsWasEmpty {
			tgts = append(tgts, NewTgt("all"))
		}
		tracef(CDebug, "inode-trust: %s", InodeTrust)
	}

	if cmdName == CmdNameRedo {
		statusInit()
	}

	killed := make(chan os.Signal, 1)
	signal.Notify(killed, syscall.SIGHUP, syscall.SIGINT, syscall.SIGTERM)
	go func() {
		<-killed
		tracef(CDebug, "[%s] killed", BuildUUID)
		jsReleaseAll()
		RunningProcsM.Lock()
		for pid, proc := range RunningProcs {
			tracef(CDebug, "[%s] killing child %d", BuildUUID, pid)
			_ = proc.Signal(syscall.SIGTERM)
		}
		os.Exit(1)
	}()

	ok := true
	err = nil
	tracef(
		CDebug, "[%s] run: %s %s cwd:%s dirprefix:%s",
		BuildUUID, cmdName, tgts, Cwd, DirPrefix,
	)

CmdSwitch:
	switch cmdName {
	case CmdNameRedo:
		for _, tgt := range tgts {
			ok, err = ifchange([]*Tgt{tgt}, true, traced)
			if err != nil || !ok {
				break
			}
		}
	case CmdNameRedoIfchange:
		ok, err = ifchange(tgts, *flagForcedIfchange, traced)
		if err == nil {
			err = depsWrite(fdDep, tgts)
		}
	case CmdNameRedoIfcreate:
		if fdDep == nil {
			log.Fatalln("no", EnvDepFd)
		}
		for _, tgt := range tgts {
			err = ifcreate(fdDep, tgt.RelTo(path.Join(Cwd, DirPrefix)))
			if err != nil {
				break
			}
		}
	case CmdNameRedoAlways:
		if fdDep == nil {
			log.Fatalln("no", EnvDepFd)
		}
		err = always(fdDep)
	case CmdNameRedoCleanup:
		for _, what := range tgts {
			err = cleanupWalker(Cwd, what.t)
			if err != nil {
				break
			}
		}
	case CmdNameRedoDot:
		err = dotPrint(tgts)
	case CmdNameRedoStamp:
		if fdDep == nil {
			log.Fatalln("no", EnvDepFd)
		}
		err = stamp(fdDep, os.Stdin)
	case CmdNameRedoLog:
		if len(tgts) != 1 {
			log.Fatal("single target expected")
		}
		err = showBuildLog(tgts[0], nil, 0)
	case CmdNameRedoWhichdo:
		if len(tgts) != 1 {
			log.Fatal("single target expected")
		}
		var fdTmp *os.File
		fdTmp, err = os.CreateTemp("", "whichdo")
		if err != nil {
			err = ErrLine(err)
			break
		}
		if err = os.Remove(fdTmp.Name()); err != nil {
			err = ErrLine(err)
			break
		}
		tgt := tgts[0]
		doFile, upLevels, err := findDo(fdTmp, tgt.h, tgt.t)
		if err != nil {
			err = ErrLine(err)
			break
		}
		_, err = fdTmp.Seek(0, io.SeekStart)
		if err != nil {
			err = ErrLine(err)
			break
		}
		r := recfile.NewReader(fdTmp)
		for {
			m, err := r.NextMap()
			if err != nil {
				if errors.Is(err, io.EOF) {
					break
				}
				err = ErrLine(err)
				break CmdSwitch
			}
			fmt.Println(cwdMustRel(tgt.h, m["Target"]))
		}
		if doFile == "" {
			ok = false
		} else {
			p := make([]string, 0, upLevels+2)
			p = append(p, tgt.h)
			for i := 0; i < upLevels; i++ {
				p = append(p, "..")
			}
			p = append(p, doFile)
			rel := mustRel(Cwd, path.Join(p...))
			fmt.Println(rel)
		}
	case CmdNameRedoTargets:
		raws := make([]string, 0, len(tgts))
		for _, tgt := range tgts {
			raws = append(raws, tgt.String())
		}
		if tgtsWasEmpty {
			raws = []string{Cwd}
		}
		raws, err = targetsWalker(raws)
		if err != nil {
			err = ErrLine(err)
			break
		}
		sort.Strings(raws)
		for _, tgt := range raws {
			fmt.Println(tgt)
		}
	case CmdNameRedoAffects:
		if tgtsWasEmpty {
			log.Fatal("no targets specified")
		}
		var res []string
		{
			var tgtsKnown []string
			tgtsKnown, err = targetsWalker([]string{Cwd})
			if err != nil {
				err = ErrLine(err)
				break
			}
			deps := make(map[string]map[string]*Tgt)
			for _, tgt := range tgtsKnown {
				collectDeps(NewTgt(tgt), 0, deps, true, make(map[string]struct{}))
			}
			seen := make(map[string]*Tgt)
			for _, tgt := range tgts {
				collectWholeDeps(deps[tgt.a], deps, seen)
			}
			res = make([]string, 0, len(seen))
			for _, dep := range seen {
				res = append(res, dep.String())
			}
		}
		sort.Strings(res)
		for _, dep := range res {
			fmt.Println(dep)
		}
	case CmdNameRedoOOD:
		raws := make([]string, 0, len(tgts))
		for _, tgt := range tgts {
			raws = append(raws, tgt.String())
		}
		if tgtsWasEmpty {
			raws, err = targetsWalker([]string{Cwd})
			if err != nil {
				break
			}
		}
		sort.Strings(raws)
		var ood bool
		for _, tgt := range raws {
			ood, err = isOOD(NewTgt(tgt), 0, nil)
			if err != nil {
				err = ErrLine(err)
				break
			}
			if ood {
				fmt.Println(tgt)
			}
		}
	case CmdNameRedoSources:
		srcs := make(map[string]*Tgt)
		{
			raws := make([]string, 0, len(tgts))
			for _, tgt := range tgts {
				raws = append(raws, tgt.String())
			}
			if tgtsWasEmpty {
				raws, err = targetsWalker([]string{Cwd})
				if err != nil {
					err = ErrLine(err)
					break
				}
			}
			sort.Strings(raws)
			tgts = tgts[:0]
			for _, raw := range raws {
				tgts = append(tgts, NewTgt(raw))
			}
			seen := make(map[string]struct{})
			seenDeps := make(map[string]struct{})
			err = ErrLine(sourcesWalker(tgts, seen, seenDeps, srcs))
		}
		if err != nil {
			break
		}
		res := make([]string, 0, len(srcs))
		for _, tgt := range srcs {
			res = append(res, tgt.String())
		}
		srcs = nil
		sort.Strings(res)
		for _, src := range res {
			fmt.Println(src)
		}
	case CmdNameRedoDepFix:
		err = depFix(Cwd)
	case CmdNameRedoInode:
		var inode *Inode
		for _, tgt := range tgts {
			inode, err = inodeFromFileByPath(tgt.a)
			if err != nil {
				err = ErrLine(err)
				break
			}
			err = recfileWrite(os.Stdout, append(
				[]recfile.Field{{Name: "Target", Value: tgt.String()}},
				inode.RecfileFields()...)...)
			if err != nil {
				err = ErrLine(err)
				break
			}
		}
	default:
		log.Fatalln("unknown command", cmdName)
	}
	if err != nil {
		log.Print(err)
	}
	rc := 0
	if !ok || err != nil {
		rc = 1
	}
	tracef(CDebug, "[%s] finished: %s %s", BuildUUID, cmdName, tgts)
	os.Exit(rc)
}